{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistics analysis\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### T Test\n",
    "\n",
    "A t-test is a statistical test that is used to compare the means of two groups. \n",
    "\n",
    "\n",
    "A t-test can only be used when comparing the means of two groups (a.k.a. pairwise comparison). If you want to compare more than two groups, or if you want to do multiple pairwise comparisons, use an ANOVA test.\n",
    "\n",
    "The t-test is a parametric test of difference, meaning that it makes the same assumptions about your data as other parametric tests. The t-test assumes your data:\n",
    "\n",
    "- are independent\n",
    "- are (approximately) normally distributed.\n",
    "- have a similar amount of variance within each group being compared (a.k.a. homogeneity of variance)\n",
    "\n",
    "If your data do not fit these assumptions, you can try a nonparametric alternative to the t-test, such as the Wilcoxon Signed-Rank test for data with unequal variances.\n",
    "\n",
    "One-sample, two-sample, or paired t-test?\n",
    "- If the groups come from a single population (e.g. measuring before and after an experimental treatment), perform a paired t-test.\n",
    "- If the groups come from two different populations (e.g. two different species, or people from two separate cities), perform a two-sample t-test (a.k.a. independent t-test).\n",
    "- If there is one group being compared against a standard value (e.g. comparing the acidity of a liquid to a neutral pH of 7), perform a one-sample t-test.\n",
    "\n",
    "t检验最常见的四个用途：\n",
    "\n",
    "- 单样本均值检验（One-sample t-test） 用于检验 总体方差未知、正态数据或近似正态的 **单样本的均值是否与已知的总体均值相等**\n",
    "- 两独立样本均值检验（Independent two-sample t-test） 用于检验**两对独立的正态数据或近似正态的样本的均值是否相等**，这里可根据总体方差是否相等分类讨论\n",
    "- 配对样本均值检验（Dependent t-test for paired samples） 用于检验**一对配对样本的均值的差是否等于某一个值**\n",
    "- 回归系数的显著性检验（t-test for regression coefficient significance） 用于检验**回归模型的解释变量对被解释变量是否有显著影响**\n",
    "\n",
    "关于T检验的进一步学习资料\n",
    "（1）基本前提条件：\n",
    "    样本数据符合正态分布\n",
    "    各个样本之间是独立的\n",
    "\n",
    "- [方差分析、T检验、卡方分析如何区分](https://zhuanlan.zhihu.com/p/57756620)\n",
    "- [三种T检验的详细区分](https://zhuanlan.zhihu.com/p/68736699)\n",
    "- [一文详解t检验](https://zhuanlan.zhihu.com/p/138711532)\n",
    "\n",
    "scipy是Python的一个科学计算库，它导入了numpy库中的所有命名空间，而且包含其他的一些库。\n",
    "pip install scipy\n",
    "其中的stats库是一个提供统计功能的库，import scipy.stats 进行导入\n",
    "\n",
    "### Performing a t-test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_1sampResult(statistic=-9.726160800478098, pvalue=4.3298236118261886e-16)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy import stats\n",
    "\n",
    "# T test\n",
    "data = pd.DataFrame({'x': np.random.normal(size = 100)})\n",
    "  # np.random.normal(loc=0.0, scale=1.0, size=None).正太分布.\n",
    "  #    loc(float)：此概率分布的均值（对应着整个分布的中心centre\n",
    "  #    scale(float)：此概率分布的标准差（对应于分布的宽度，scale越大，图形越矮胖；scale越小，图形越瘦高）\n",
    "  #    size(int or tuple of ints)：输出的shape，默认为None，只输出一个值\n",
    "    \n",
    "stats.ttest_1samp(data['x'], 1)\n",
    "  # .ttest_1samp（）：单样本t检验\n",
    "  #   （1）data['x']：样本数据\n",
    "  #   （2）第二个参数：总体均值。\n",
    "  #    if pvalue < 0.05, we could reject H0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其他的example：\n",
    "rvs = stats.norm.rvs(loc=2.5, scale=1, size=(50)) \t\t\t\t# 生成均值为1.5，标准差为1的样本\n",
    "t, p = ttest_1samp(rvs, 1.7)\t\t\t\t\t\t\t# 进行单样本t检验，返回对应的t值和p值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.004633852283443361"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['x'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x000002208A321A90>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAEICAYAAAB/Dx7IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAE0JJREFUeJzt3X+M23d9x/HXi7SladylQMCU0O3KhrpBT0DjMaAT8rUMhQbRTWOsiDG6wU7VBisjSGRCG9okRNhUJLYxbeGHYKLrMUKzdQ2/uhGvQlrL7rq215LyoyUbTbqU0pFypSqEvffHOYm5fG1//LW/tj/k+ZBO8dmf7/f7us/Zr9hff79nR4QAAPl4wqQDAAAGQ3EDQGYobgDIDMUNAJmhuAEgMxQ3AGSG4gaAzFDcAJAZihsAMkNx48ee7Z+2/bDti9rfP8P2Q7abE44GlGJOecepwPbvSHqbpC2S9khajoi3TzYVUA7FjVOG7RsknS8pJP18RDw+4UhAKewqwankg5IulPSXlDZyxjNunBJs1yTdIWmfpFdImo2IhyebCiiH4sYpwfaHJZ0dEa+xvUvSORHxmknnAspgVwl+7Nm+XNJWSVe1r3qbpItsv25yqYDyeMYNAJnhGTcAZIbiBoDMUNwAkBmKGwAyc1oVK920aVPMzMyUXv7RRx/Vhg0bRhdohMhWDtkGN625JLKV1Svb0tLSQxHx1KQVRcTIv7Zs2RLD2Ldv31DLV4ls5ZBtcNOaK4JsZfXKJmkxEjuWXSUAkBmKGwAyQ3EDQGYobgDIDMUNAJmhuAEgM0nFbfsPbN9t+y7b19k+s+pgAIBifYvb9mZJvy+pEREXSlon6YqqgwEAiqXuKjlN0nrbp0k6S9Kh6iIBAHpJ+nvctq+W9G5Jj0n6fESc9Afobc9Lmpeker2+ZWFhoXSolZUV1Wq10stXiWzlnOrZlg8eKbx+dvPGrsuc6nNWVq7Z5ubmliKikbKevsVt+0mSPiXp1yV9R9InJe2OiI93W6bRaMTi4mLK9gu1Wi01m83Sy1eJbOWc6tlmduwtvP7Azm1dlznV56ysXLPZTi7ulF0lL5P0jYj4VkT8QNL1kl6SGhQAMFopxf3fkl5k+yzblnSppP3VxgIAdNO3uCPiVkm7Jd0mabm9zK6KcwEAukj6e9wR8S5J76o4CwAgAWdOAkBmKG4AyAzFDQCZobgBIDMUNwBkhuIGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMUNwAkBmKGwAy07e4bV9g+/aOr0dsv3Uc4QAAJ+v7CTgR8RVJz5ck2+skHZS0p+JcAIAuBt1VcqmkeyPiv6oIAwDob9DivkLSdVUEAQCkcUSkDbTPkHRI0nMj4nDB7fOS5iWpXq9vWVhYKB1qZWVFtVqt9PJVIls5p3q25YNHCq+f3byx6zKn+pyVlWu2ubm5pYhopKxnkOK+XNLvRcTL+41tNBqxuLiYtN4irVZLzWaz9PJVIls5p3q2mR17C68/sHNb12VO9TkrK9dstpOLe5BdJa8Vu0kAYOKSitv2WZJ+SdL11cYBAPTT93BASYqI70l6SsVZAAAJOHMSADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMUNwAkBmKGwAyQ3EDQGYobgDIDMUNAJmhuAEgMxQ3AGSG4gaAzFDcAJAZihsAMpP60WXn2N5t+x7b+22/uOpgAIBiSR9dJun9kj4bEa+2fYaksyrMBADooW9x2/4JSS+VdKUkRcT3JX2/2lgAgG4cEb0H2M+XtEvSlyU9T9KSpKsj4tE14+YlzUtSvV7fsrCwUDrUysqKarVa6eWrRLZ0ywePHL9cXy8dfuzEbbObN04gUbFxzFvnXHTqNQ/T9vvsRLZyemWbm5tbiohGynpSirsh6RZJF0fErbbfL+mRiPijbss0Go1YXFxM2X6hVqulZrNZevkqkS3dzI69xy9vnz2qa5ZPvMA7sHPbJCIVGse8dc5Fp17zMG2/z05kK6dXNtvJxZ3y5uT9ku6PiFvb3++WdFHKygEAo9e3uCPifyR90/YF7asu1epuEwDABKQeVfIWSde2jyi5T9JvVRcJANBLUnFHxO2Skva9AACqxZmTAJAZihsAMkNxA0BmKG4AyAzFDQCZobgBIDMUNwBkhuIGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMUNwAkJmkT8CxfUDSdyX9UNLR1E8iBgCMXupnTkrSXEQ8VFkSAEASdpUAQGYcEf0H2d+Q9L+SQtLfRsSugjHzkuYlqV6vb1lYWCgdamVlRbVarfTyVSJbuuWDR45frq+XDj924rbZzRsnkKhYmXnr/Nk6dfu5Bh1fNte4kK2cXtnm5uaWUndDpxb3MyLikO2nSbpJ0lsi4uZu4xuNRiwuLqZsv1Cr1VKz2Sy9fJXIlm5mx97jl7fPHtU1yyf2zB3YuW0SkQqVmbfOn61Tt59r0PFlc40L2crplc12cnEn7SqJiEPtfx+UtEfSC9NiAgBGrW9x295g++xjlyW9XNJdVQcDABRLOaqkLmmP7WPj/z4iPltpKgBAV32LOyLuk/S8MWQBACTgcEAAyAzFDQCZobgBIDMUNwBkhuIGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMUNwAkBmKGwAyQ3EDQGYobgDITHJx215n+z9t31hlIABAb4M8475a0v6qggAA0iQVt+1nStom6UPVxgEA9OOI6D/I3i3pPZLOlvT2iHhlwZh5SfOSVK/XtywsLJQOtbKyolqtVnr5KuWYbfngkcLxs5s3Vpqnc7v19dLhx0a/7UF/tqLxa7MNY5Dt9hov5Xlfmwa5Zpubm1uKiEbKevp+yrvtV0p6MCKWbDe7jYuIXZJ2SVKj0Yhms+vQvlqtloZZvko5Zrtyx97C8Qded/LYUerc7vbZo7pm+cTdbVTbHvRnKxq/NtswBtlur/FSnve1aXAqZEvZVXKxpFfZPiBpQdIltj8+9JYBAKX0Le6I+MOIeGZEzEi6QtIXIuI3Kk8GACjEcdwAkJmBduxFREtSq5IkAIAkPOMGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMUNwAkBmKGwAyQ3EDQGYobgDIDMUNAJmhuAEgMxQ3AGSG4gaAzPQtbttn2v6S7Tts3237T8YRDABQLOWjyx6XdElErNg+XdIXbX8mIm6pOBsAoEDf4o6IkLTS/vb09ldUGQoA0J1Xe7nPIHudpCVJPyPpAxHxjoIx85LmJaler29ZWFgoHWplZUW1Wq308lU6lm354JHC22c3bxxzohO6zVu3rN0M+jOkrL++Xjr8WP9tDDqvoxi/NtswRpVTGt3joIr7ag6P0WnUK9vc3NxSRDRS1pNU3McH2+dI2iPpLRFxV7dxjUYjFhcXk9e7VqvVUrPZLL18lY5lm9mxt/D2Azu3jTnRCd3mrVvWbgb9GVLWv332qK5ZPvECr9s2Bp3XUYxfm20Yo8opje5xUMV9NYfH6DTqlc12cnEPdFRJRHxHUkvS1kGWAwCMTspRJU9tP9OW7fWSXibpnqqDAQCKpbw+PFfSx9r7uZ8g6R8i4sZqYwEAukk5quROSS8YQxYAQALOnASAzFDcAJAZihsAMkNxA0BmKG4AyAzFDQCZobgBIDMUNwBkhuIGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMpHzm5Hm299neb/tu21ePIxgAoFjKZ04elbQ9Im6zfbakJds3RcSXK84GACjQ9xl3RDwQEbe1L39X0n5Jm6sOBgAo5ohIH2zPSLpZ0oUR8cia2+YlzUtSvV7fsrCwUCrQ8sEjqq+XDj/2o9fPbt5Yan2jtrKyolqtpuWDRwpv75Vz0GW6je+maN5GaZicVWcbxrRmO3/jOtVqtaHXM+j9KOWxduxxUGb9w2w3RWe2YZV5nPfSK9vc3NxSRDRS1pNc3LZrkv5N0rsj4vpeYxuNRiwuLiatd62ZHXu1ffaorln+0b04B3ZuK7W+UWu1Wmo2m5rZsbfw9l45B12m2/huiuZtlIbJWXW2YUxrto9u3aBmszn0ega9H6U81o49Dsqsf5jtpujMNqwyj/NeemWznVzcSUeV2D5d0qckXduvtAEA1Uo5qsSSPixpf0S8r/pIAIBeUp5xXyzp9ZIusX17++uyinMBALrou2MvIr4oyWPIAgBIwJmTAJAZihsAMkNxA0BmKG4AyAzFDQCZobgBIDMUNwBkhuIGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmaG4ASAzFDcAZIbiBoDMUNwAkJmUz5z8iO0Hbd81jkAAgN5SnnF/VNLWinMAABL1Le6IuFnSw2PIAgBI4IjoP8iekXRjRFzYY8y8pHlJqtfrWxYWFkoFWj54RPX10uHHSi1+3OzmjcOtoCNPp37Zem137bpGbRTzVhWyDe78jetUq9VOur7q+1GKaZmzosfbyspK4bxJ1c9dv97plW1ubm4pIhop2xlZcXdqNBqxuLiYMvQkMzv2avvsUV2z3PcD6Hs6sHPbUMt35unUL1uv7a5d16iNYt6qQrbBfXTrBjWbzZOur/p+lGJa5qzo8dZqtQrnTap+7vr1Tq9stpOLm6NKACAzFDcAZCblcMDrJP27pAts32/7jdXHAgB003cnVUS8dhxBAABp2FUCAJmhuAEgMxQ3AGSG4gaAzFDcAJAZihsAMkNxA0BmKG4AyAzFDQCZobgBIDMUNwBkhuIGgMxQ3ACQGYobADJDcQNAZihuAMgMxQ0AmUkqbttbbX/F9tdt76g6FACgu5TPnFwn6QOSXiHpOZJea/s5VQcDABRLecb9Qklfj4j7IuL7khYkXV5tLABAN46I3gPsV0vaGhFvan//ekm/EBFvXjNuXtJ8+9sLJH1liFybJD00xPJVIls5ZBvctOaSyFZWr2w/FRFPTVlJ3095l+SC605q+4jYJWlXykb7btBejIjGKNY1amQrh2yDm9ZcEtnKGlW2lF0l90s6r+P7Z0o6NOyGAQDlpBT3f0h6tu3zbZ8h6QpJN1QbCwDQTd9dJRFx1PabJX1O0jpJH4mIuyvONZJdLhUhWzlkG9y05pLIVtZodif3e3MSADBdOHMSADJDcQNAZqaiuG3/ue17bN9pe4/tc7qMG/up97Z/zfbdtv/PdtfDeGwfsL1s+3bbi1OWbRLz9mTbN9n+WvvfJ3UZ98P2nN1uu7I3vfvNge0n2v5E+/Zbbc9UlaVEtittf6tjnt40xmwfsf2g7bu63G7bf9HOfqfti6YkV9P2kY45++Nx5Gpv+zzb+2zvbz8+ry4YM9y8RcTEvyS9XNJp7cvvlfTegjHrJN0r6VmSzpB0h6TnjCHbz2n1hKKWpEaPcQckbRrzvPXNNsF5+zNJO9qXdxT9Ttu3rYwhS985kPS7kv6mffkKSZ8Y0+8wJduVkv5qnPetjm2/VNJFku7qcvtlkj6j1fM9XiTp1inJ1ZR044Tm7FxJF7Uvny3pqwW/06HmbSqecUfE5yPiaPvbW7R6rPhaEzn1PiL2R8QwZ4FWJjHbpP5kweWSPta+/DFJvzyGbXaTMgedeXdLutR20clnk8g2MRFxs6SHewy5XNLfxapbJJ1j+9wpyDUxEfFARNzWvvxdSfslbV4zbKh5m4riXuO3tfo/0VqbJX2z4/v7dfJkTFJI+rztpfbp/9NiUvNWj4gHpNU7sqSndRl3pu1F27fYrqrcU+bg+Jj2k4gjkp5SUZ5Bs0nSr7ZfUu+2fV7B7ZMyzY/LF9u+w/ZnbD93EgHau9xeIOnWNTcNNW8pp7yPhO1/kfT0gpveGRH/1B7zTklHJV1btIqC60ZyLGNKtgQXR8Qh20+TdJPte9rPCiadbSLzNsBqfrI9b8+S9AXbyxFx7yjydUiZg8rmqY+U7f6zpOsi4nHbV2n1lcEllSdLM6l56+c2rf7tjxXbl0n6R0nPHmcA2zVJn5L01oh4ZO3NBYskz9vYijsiXtbrdttvkPRKSZdGeyfQGpWdet8vW+I6DrX/fdD2Hq2+BB66uEeQbSLzZvuw7XMj4oH2S8AHu6zj2LzdZ7ul1Wcnoy7ulDk4NuZ+26dJ2qjxvBTvmy0ivt3x7Qe1+j7QtJjKP4nRWZQR8Wnbf217U0SM5Y9P2T5dq6V9bURcXzBkqHmbil0ltrdKeoekV0XE97oMm9pT721vsH32sctafbO18N3uCZjUvN0g6Q3ty2+QdNKrA9tPsv3E9uVNki6W9OUKsqTMQWfeV0v6QpcnEGPPtmbf56u0us90Wtwg6TfbR0m8SNKRY7vIJsn204+9R2H7hVrtum/3Xmpk27akD0vaHxHv6zJsuHmbxLuuBe/Cfl2r+3tub38de3f/GZI+vead2K9q9RnZO8eU7Ve0+r/j45IOS/rc2mxaPSLgjvbX3dOUbYLz9hRJ/yrpa+1/n9y+viHpQ+3LL5G03J63ZUlvrDDPSXMg6U+1+mRBks6U9Mn2ffFLkp41jnlKzPae9v3qDkn7JP3sGLNdJ+kBST9o39feKOkqSVe1b7dWP2jl3vbvsOuRV2PO9eaOObtF0kvGOGe/qNXdHnd2dNplo5w3TnkHgMxMxa4SAEA6ihsAMkNxA0BmKG4AyAzFDQCZobgBIDMUNwBk5v8BAlfnqrVk/QYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "pd.DataFrame({'x': np.random.normal(size = 100)}).hist(bins = 50)\n",
    "  # DataFrame.hist()：画出某一列中的值的分布直方图。\n",
    "  #    使用函数Pandas DataFrame.hist()时，它将在DataFrame中的每个系列上自动调用函数matplotlib.pyplot.hist()。结果，我们获得了每列一个直方图。\n",
    "  #    bins = 50：默认为10，指定显示多少竖条。\n",
    "data.hist(bins = 50)\n",
    "plt.show()\n",
    "  # 两张图不一样，是因为第一张图是重新random了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x0000023F396BECF8>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x1 = 5 + np.random.normal(size = 50)\n",
    "x2 = -5 + np.random.normal(size = 50)\n",
    "data = pd.DataFrame({'x': np.concatenate((x1, x2))})\n",
    "  # np.concatenate（）：连接，拼接。\n",
    "data.hist(bins = 50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16063284060545877"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['x'].mean()\n",
    " # 结果：-0.041493115277059005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_1sampResult(statistic=-5.981430105208992e-16, pvalue=0.9999999999999996)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.ttest_1samp(data['x'], -0.041493115277059005)\n",
    "  # 结果：TtestResult(statistic=0.0, pvalue=1.0, df=99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两独立样本T检验(两总体方差相等时，即具有方差齐性，可以直接检验）\n",
    "\n",
    "当不确定两总体方差是否相等时，应先利用levene检验，检验两总体是否具有方差齐性。\n",
    "如果返回结果的p值远大于0.05，那么我们认为两总体具有方差齐性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LeveneResult(statistic=0.9620488794645203, pvalue=0.3290864382224974)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.levene(x1,x2)\n",
    "  # 检验结果为p>0.05，可以认为方差是相等的\n",
    "  #    结果：LeveneResult(statistic=1.0699125651323425, pvalue=0.303510950965132) ---- 方差是相等的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=46.81689307179705, pvalue=7.150254749524651e-69)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.ttest_ind(x1,x2)\n",
    "  # ttest_ind（）：两独立样本t检验\n",
    "  #    stats.ttest_ind(A,B,equal_var=True)\t\t\t\t# 进行独立样本t检验。equal_var=False\n",
    "  #    if P value < 0.05, the H0 could be rejected, which means x1 is not equal to x2\n",
    "  #    结果：TtestResult(statistic=51.79664920267659, pvalue=5.222761136004856e-73, df=98.0)。--- 不相等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "配对t检验\n",
    "\n",
    "实现：可以选择单样本t检验的ttest_1samp函数(两组样本的差异为输入），也可以直接选择实现配对样本t检验的ttest_rel函数（两组样本作为输入)。代码如下：\n",
    "A0 = stats.norm.rvs(loc=1, scale=1, size=(100))\t\t \t # 生成去年的销售额\n",
    "A1 = stats.norm.rvs(loc=1.5, scale=1, size=(100))\t\t # 生成今年的销售额\n",
    "#计算两年销售额之间的差值\n",
    "diff = A0-A1\n",
    "#使用ttest_1samp函数计算配对样本的t统计量\n",
    "stats.ttest_1samp(diff)\n",
    "out:\n",
    "Ttest_1sampResult(statistic=13.983206457471795, pvalue=1.1154473504425075e-14)\n",
    " \n",
    "#使用ttest_rel函数计算配对样本的t统计量\n",
    "stats.ttest_rel(A0,A1)\n",
    "out:\n",
    "Ttest_relResult(statistic=-4.731625986009621, pvalue=7.412846164679422e-06)\n",
    "————————————————\n",
    "版权声明：本文为CSDN博主「修罗神天道」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。\n",
    "原文链接：https://blog.csdn.net/qq_40932679/article/details/116980016"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Chi Square 卡方检验\n",
    "\n",
    "若$n$个相互独立的随机变量，均服从标准正态分布，则这$n$个服从标准正态分布的随机变量的平方和构成一新的随机变量，其分布规律称为卡方分布$X^2$\n",
    "\n",
    "卡方检验分为拟合度的卡方检验和卡方独立性检验。\n",
    "\n",
    "- [卡方检验（Chi-Squared Test）](https://zhuanlan.zhihu.com/p/56423752)\n",
    "- [卡方检验、T检验+F检验、方差分析、Z检验](https://www.jianshu.com/p/8b7b401881d7)\n",
    "                            (https://www.jianshu.com/p/fcfac399de13?ivk_sa=1024320u)\n",
    "- [STUDENT’S TEST (T TEST) ](https://researchbasics.education.uconn.edu/t-test/#)\n",
    "\n",
    "样本的标准差是否高于期望值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.concatenate((x1, x2))\n",
    "\n",
    "c2dist = stats.chi2(len(x)-1)\n",
    "  # .chi2（）：卡方分布\n",
    "  #      len(x)-1：拟合优度检验中自由度为：k-1，k代表分类变量数。100-1=99.\n",
    "sigma = 1\n",
    "  # the distribution of x follows a standard deviation equal to sigma\n",
    "  #      P value\n",
    "c2dist.sf(sum(((x - np.mean(x)/sigma))**2))\n",
    "  # （1）卡方统计的公式：见下图。\n",
    "  #     sum(((x - np.mean(x)/sigma))**2)目的是算 卡方。\n",
    "  #     if P value is less than 0.05, it means sigma of x is significantly different from 1\n",
    "  # （2）生存函数 Survival function：\n",
    "  #     给定一个x的值，计算这个值的存活几率。就是这个值右边的概率面积，右尾的大小\n",
    "  #     比如：stats.chi2.sf(x=11.07,df=5)\n",
    "  #     生存函数：https://blog.csdn.net/qq_32515081/article/details/130190109\n",
    "  #     生存函数的意义？（课后思考）"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卡方统计的公式：![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卡方验证方法：\n",
    "\n",
    "1.卡方拟合性检验：\n",
    "    用Python计算卡方值 stats.chisquare（）\n",
    "2.卡方独立性检验：\n",
    "    stats.chi2_contingency（）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.卡方拟合性检验：\n",
    "\n",
    "卡方分析常见的应用——适合度分析\n",
    "\n",
    "常见的适合度分析的结构如下，一般有两组数据，一组是你统计或者观察到的值，另一组是理论上的预期值。如果这两组值十分接近，证明观测到的结果很“合适”，如果差距较大，则证明观测到的数据不够“合适”，这就是“适合度分析”名字的含义。\n",
    "\n",
    "这种统计分析在科学研究中是十分常用的，因为科学家经常按照理论预期来推测试验结果，而实际上由于各种误差的存在，实验数据不可能和理论预期完全一致，这时卡方检验就能很好地检验理论的正确性。\n",
    "\n",
    "卡方拟合性检验，是检验一组数据和期望值之间是否一致的问题。\n",
    "\n",
    "观测数据是测试样本的实际数据，而期望值一般是根据经验或者理论人为计算出来的。这里的自由度一般是分类个数减去1。\n",
    "\n",
    "调用函数的时候可以：stats.chisquare([31,26,18,1,24,10])。不写期望值，他会根据数数值计算一个期望着。也就是加起来除以个数。如果期望值不平均，如[20,20,20,10,20,30] ,那就要写了。否则默认是平均的。\n",
    "————————————————\n",
    "版权声明：本文为CSDN博主「PY_smallH」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。\n",
    "原文链接：https://blog.csdn.net/PY_smallH/article/details/111881468\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**举例**\n",
    "\n",
    "某科学家预言抛一个色子，各面向上的几率都相同。为了验证自己理论的正确性，该科学家抛了600次硬币，结果为一点102次，二点102次，三点96次，四点105次，五点95次，六点100次。显然这个结果和理论预期并不完全一样，那么，科学家的理论有错吗？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Power_divergenceResult(statistic=0.74, pvalue=0.980701472519648)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs = [102, 102, 96, 105, 95, 100]\n",
    "exp = [100, 100, 100, 100, 100, 100]\n",
    "  # 假设骰子是公平的，那么他理论值为[100, 100, 100, 100, 100, 100]。\n",
    "stats.chisquare(obs, f_exp = exp)\n",
    "  # If P value > 0.95, we can not reject that obs is significantly different from exp\n",
    "  # 结果：Power_divergenceResult(statistic=0.74, pvalue=0.980701472519648)\n",
    "  #       结果计算出卡方值为0.74，概率为98%，他不小于5%，所以这个筛子的结果是可以接受的 --- 公平的（接近于理论）。\n",
    "  #       注意：这个98%概率是右尾面积。一般卡方求的也都是右尾。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Power_divergenceResult(statistic=-1050.4444213168144, pvalue=1.0)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.chisquare(x1, f_exp = x2)\n",
    "  # P value to reject H0\n",
    "  # 结果：Power_divergenceResult(statistic=-1047.5858627527502, pvalue=1.0)"
   ]
  },
  {
   "attachments": {
    "20201229172329838.JPG": {
     "image/jpeg": "/9j/4AAQSkZJRgABAQEAYABgAAD/4RD0RXhpZgAATU0AKgAAAAgABAE7AAIAAAAOAAAISodpAAQAAAABAAAIWJydAAEAAAAcAAAQ0OocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFkbWluaXN0cmF0b3IAAAWQAwACAAAAFAAAEKaQBAACAAAAFAAAELqSkQACAAAAAzA1AACSkgACAAAAAzA1AADqHAAHAAAIDAAACJoAAAAAHOoAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMDIwOjEyOjI5IDE3OjIzOjA0ADIwMjA6MTI6MjkgMTc6MjM6MDQAAABBAGQAbQBpAG4AaQBzAHQAcgBhAHQAbwByAAAA/+ELIGh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iLz48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyI+PHhtcDpDcmVhdGVEYXRlPjIwMjAtMTItMjlUMTc6MjM6MDQuMDQ4PC94bXA6Q3JlYXRlRGF0ZT48L3JkZjpEZXNjcmlwdGlvbj48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyI+PGRjOmNyZWF0b3I+PHJkZjpTZXEgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj48cmRmOmxpPkFkbWluaXN0cmF0b3I8L3JkZjpsaT48L3JkZjpTZXE+DQoJCQk8L2RjOmNyZWF0b3I+PC9yZGY6RGVzY3JpcHRpb24+PC9yZGY6UkRGPjwveDp4bXBtZXRhPg0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSd3Jz8+/9sAQwAHBQUGBQQHBgUGCAcHCAoRCwoJCQoVDxAMERgVGhkYFRgXGx4nIRsdJR0XGCIuIiUoKSssKxogLzMvKjInKisq/9sAQwEHCAgKCQoUCwsUKhwYHCoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq/8AAEQgAjAKyAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A+kaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBjs/mKqFRkEkkZ6Y9/ejEv8AfT/vg/40H/j4T/cb+Yp9ADMS/wB9P++D/jRiX++n/fB/xp9FADMS/wB9P++D/jRiX++n/fB/xp9FADMS/wB9P++D/jRiX++n/fB/xrltU8fWelSa3BPbTfadN8zyF8uTy7opaC5K+aEKI23cNpJOFzjkCta88QQW0+kJb201/Fq8vlQXFq8bRr8hkDElxlSiu2VDcKe5AIBp4l/vp/3wf8aMS/30/wC+D/jXnOmfFn+0bqyi+y6KPtX2M+XFrfmTD7RJ5e0R+SMyR9XXIwCOea9JoAZiX++n/fB/xoxL/fT/AL4P+NPooAZiX++n/fB/xoxL/fT/AL4P+NPooAiUyszDenynH3D6A+vvTsS/30/74P8AjRH9+X/f/wDZRT6AGYl/vp/3wf8AGjEv99P++D/jT6KAGYl/vp/3wf8AGjEv99P++D/jT6KAGYl/vp/3wf8AGjEv99P++D/jXPeJPHOk+Gv7RhvbiGO8tLD7bDBPOkX2rPmBY0JOS2YiDgHG5eucU+08b6Bd39zbrrWklI08yKWLUoX8xAhZyVBypXaxPBG3B3feCgG9iX++n/fB/wAaMS/30/74P+NcfqXxHt9OlQyaVMts11Pb/aLm+s7cSeSzI7RiSYFsOoGCF4OfQGfUPiFpWm2NhPeNDbSX3lOsNzfW6ssTzJGJPlkbcu1mkBXK7Y2yVNAHU4l/vp/3wf8AGjEv99P++D/jWDovjPS9Y1Gew+02tvdq8fkWzXcbyzo1vHNvCqSCAJCMqWHyEgkV0NADMS/30/74P+NGJf76f98H/Gn0UAMxL/fT/vg/40Yl/vp/3wf8afRQBE5lSNm3odoJxsP+NOxL/fT/AL4P+NE//HvJ/uH+VPoAZiX++n/fB/xoxL/fT/vg/wCNPooAZiX++n/fB/xoxL/fT/vg/wCNPooAZiX++n/fB/xoxL/fT/vg/wCNPpk8y29vJPIHKRoXYRxs7EAZ4VQSx9gCT2oAMS/30/74P+NGJf76f98H/Guaj8eae+s3NibHVgkNvFMJBpF2WYu0gIKeVlQPLGGPDZIH3TRq/wAQND0e4urW5vbWK7tL23tZILi5SJispiJlUEklFWXJOB9xhwBmgDpcS/30/wC+D/jRiX++n/fB/wAaxdK8YaNqks8Meq6Y0sUu1Vg1CKYSIWVUcYORkuq4IHznA3DazYUnxSs4fsUs+kzW1teWouomutRsYZGRseWwje4BKkbuSRgqBg5OADt8S/30/wC+D/jRiX++n/fB/wAa5bWPiFpWi31tZ3rQxXMmPPt5r63SSDMMkoVgZMBsoi5YqmZVwx5rT0PxRp2tzXNrFdWq39tcXEUtmtwryosUzRbyvUA4U8jjcBk9SAa2Jf76f98H/GjEv99P++D/AI0+igBmJf76f98H/GjEv99P++D/AI0+igBmJf76f98H/GjEv99P++D/AI0+igCIGUyFd6cAHOw98+/tTsS/30/74P8AjQP+Ph/9xf5mn0AMxL/fT/vg/wCNGJf76f8AfB/xp9FADMS/30/74P8AjRiX++n/AHwf8afRQAzEv99P++D/AI0Yl/vp/wB8H/GsmfxJDDcSOIHfTLdzFdagCPLhkBweOpRSCHccISAfuyGPSlluI7y3SO282CTcJZRIAYiBlSVPVTggkHIJXggkqASYl/vp/wB8H/GjEv8AfT/vg/41U0/Uvt99qlv5Xl/2fdLb7t2fMzDFLuxjj/W4xz0z3wL1ADMS/wB9P++D/jRiX++n/fB/xp9FADMS/wB9P++D/jRiX++n/fB/xp9FAESGV1J3oOSPuHscetOxL/fT/vg/40Q/cP8Avt/6EafQAzEv99P++D/jRiX++n/fB/xp9FADMS/30/74P+NGJf76f98H/Gn0UAMxL/fT/vg/40Yl/vp/3wf8afXGJ8T/AA9c/Yvsmp6Yv2ywkuh9r1COLyZB5eyGXG7azeY2epHltgN2AOwxL/fT/vg/40Yl/vp/3wf8awW8a6Q2iR6hZTJfvI8ca2lncwyy+Y7xx7MiTZlWmjDHdgbhzyM0dO+IMN/4gbRzpbx3RuPJWNdSsZJFAA3l41nLAqQ+VAY4XPU4AB1mJf76f98H/GjEv99P++D/AI1ycvj2Vbjy4vDWoOkKSS3chu7MLbxIWVmZhOVB3qVwxX7shGdjCrz+Lo4tLF5NpN8rGaSIW6vbyPiMEyNlJSuF2sCN27KkYzjIBvYl/vp/3wf8aMS/30/74P8AjUFpqMF7czxW+5xBs3SY+Ull3bR3yAVJ4/iHvi1QAzEv99P++D/jRiX++n/fB/xp9FADMS/30/74P+NGJf76f98H/Gn0UAMxL/fT/vg/40gLiUK5UgqTwuOmPf3qSmH/AI+E/wBxv5igB9FFFABRRRQAw/8AHwn+438xT6Yf+PhP9xv5in0AFFFFABRRRQB5XrVoD4c1ItdPNor298+m3dz5cUcl3PDsMjSZUKjtJcFXbEbGcgBQsJk09TbRJtV0XU9GvJtQs49alvLmSwuz9ls1+ysJGd0YRou4pIwc7m8yXAbeyn0GigDxLQSreK7bSz4m0yezhi0yOOJNdt381YZ5GjjUi0UyMpAOwFW+YZY7ht9toooAKKKKACiiigBkf35f9/8A9lFPpkf35f8Af/8AZRT6ACiiigAooooA5PxzcedZw6b9t/sxXljmN88W8rIhLwJCp/10pljQ+WoYlFcfKWTNXQdeurMX39vas63D24ktLTWAltnZGzyOJRBGGTBBICs0aqC4VmMa9tRQB4Pq1rc6ULCG41610QwW9z9mtY7l9OdReXNwI5BGBuEYb7M7IZMxrCwZCTzbup3PhrRLHzrLW7axiaWNoNVZGhS3uHVCjJApThI0N2wVAscgDR+Zvb22igDhdDt/svxAkY3nnWo+1Q28zjCzTMtqZUXaoTzBJbzyOFwCzsRkrKE7qiigAooooAKKKKAGT/8AHvJ/uH+VPpk//HvJ/uH+VPoAKKKKACiiigAqjrUfm6POn2a9us7f3NhceRM3zD7r70x6n5hkAjnODeooA8vt/CN7D4y1GZr7U7qWOwtJpbCLWLlVZXkuB5ccpkDllCAqXO1maTiMODHpeKLmaQaXb2t1daPNp6efbCZTPdXFwIwvlIMSmUCKWQSSKsgVmRgX2OK76igDibTWGXw/qllrOpJc37O2LLWLdRLHAxWLBijjX7QCxOPLUq7t5Su3DnzbU9Pmhlj0rV/Etrp8x02z0iSyOrm18jZBFKwlATaUK/alEhMqlp0XaMHHv9FAHkEl5d6xr2gS3NxDfyxRWcn9p2l+Y5IZJ4lTITydkKku8nly7TOTEoLBfKHU+CI1g1zUCJkME1uFsAoYLLbJdXLq0WQAY1SeJBjgYGBsaNn7aigAooooAKKKKACiiigBg/4+H/3F/mafTB/x8P8A7i/zNPoAKKKKACmTwQ3VvJb3MSTQyoUkjkUMrqRggg8EEdqfRQB47pXn6ho1leLqGoWYuLeOUW1no+t+TDuUHZH5dyE2DOBsAXAGBjFbv9mQ3vh7wVq+k+HLVbydFMg06MWohjms5yw81fmijEkuSQSQTkBmwD6LRQByHhbQbO08SeIJ4ptQZ7bUlRBLqVxIpBs7cncrOQ5+Y8sCRxj7ox19FFABRRRQAUUUUAMh+4f99v8A0I0+mQ/cP++3/oRp9ABRRRQAUUUUAFebanfahceI7rUtJ1C9guHiED6dZW6tMkCIZIZJ90MvksWkmOwhWaNl2qZEMbek0UAcLqlx/b2meHbKyvbLV7uC/tZbmVots4kgkiaZvK48hgrMX3EFdwj2lpBjz3w7M/8AwkOjzf8ACZWVxcrfx3rquqM8cxunRGWODysCTJutyBEMYuIyXODXvlFAHkHiWw1qfxfpWqR+HvJu57/MT3GmWMkm9I2dAHW6BbEcOMORyzuCGESp20OmPfeD0ttQ0W586wylrbu8Vs0gVdqD9xIUClTtYZCnDfIFIWupooA5DSdE1bTfEsQZ7mS2UbpLj7RiCRTH8yeVu4kMxL7tvC4Xdxtrr6KKdxJWCiiikMKKKKACmH/j4T/cb+Yp9MP/AB8J/uN/MUAPooooAKKKKAIpEV50DqGG1uCM9xTvIi/55J/3yKD/AMfCf7jfzFPoAZ5EX/PJP++RR5EX/PJP++RT6KAGeRF/zyT/AL5FHkRf88k/75FPooAZ5EX/ADyT/vkUeRF/zyT/AL5FeVyW2t3eo2csYmlju9fv7YMfEt7B5qIbrahjRSsSr5QwUJzsUYAY40rXU9ZtvDek2ggup3l1e6geSO/Mjq8V4/lQmRz5jRkKd7hXIijfKc5UA9C8iL/nkn/fIo8iL/nkn/fIrgdL1rXpfFFj9ouNTNnc61fWZ8xLT7K0cQudiptHnBh5KctwdrcnIz6DQAzyIv8Ankn/AHyKPIi/55J/3yKfRQAzyIv+eSf98ijyIv8Ankn/AHyKfRQBAkMReTMacNx8o9BUnkRf88k/75FEf35f9/8A9lFPoAZ5EX/PJP8AvkUeRF/zyT/vkU+igBnkRf8APJP++RR5EX/PJP8AvkU+igBnkRf88k/75FHkRf8APJP++RT6hvZnt7C4miRpHjjZ1RF3FiBkAAdTSbsrjSu7D/Ii/wCeSf8AfIo8iL/nkn/fIrldCOr3VlNZX+q6ra6m8cchN7DaFkTPzPEIlwATkfvMkYGV9dTwzc3dzY3P2m5e9hjuWS1vJFVWuIwB8xCKq/e3KCAAQoPOcmrE3NbyIv8Ankn/AHyKPIi/55J/3yKfRSGM8iL/AJ5J/wB8ijyIv+eSf98in0UAM8iL/nkn/fIo8iL/AJ5J/wB8in0UAQTQxCCQiNAQp52j0qTyIv8Ankn/AHyKJ/8Aj3k/3D/Kn0AM8iL/AJ5J/wB8ijyIv+eSf98in0UAM8iL/nkn/fIo8iL/AJ5J/wB8in0UAM8iL/nkn/fIo8iL/nkn/fIp9FADPIi/55J/3yKPIi/55J/3yKfRQAzyIv8Ankn/AHyKPIi/55J/3yK5dtV1uK1103clvHLbzRCLyF3rbRMF3NkgbioJYkgDjpgVa8L6xHqM19a2+qNrEFqYzHqB8siXeCSA0aqjbSCMqPY8g0k7gb3kRf8APJP++RR5EX/PJP8AvkU+imAzyIv+eSf98ijyIv8Ankn/AHyKfRQAzyIv+eSf98ijyIv+eSf98in0UAM8iL/nkn/fIo8iL/nkn/fIp9FAEAhi89h5aY2rxtHqak8iL/nkn/fIoH/Hw/8AuL/M0+gBnkRf88k/75FHkRf88k/75FPooAZ5EX/PJP8AvkUeRF/zyT/vkU+igBnkRf8APJP++RR5EX/PJP8AvkVl+JS8Ojy3i6pe6etspkY2aQs0vHC4kRxknAGMcmsq7l8SaT4c0nzr6Ge5Nzbpf3MqLvYSTopRFVQvRyN3ovTJyotXb+tQOp8iL/nkn/fIo8iL/nkn/fIp9FADPIi/55J/3yKPIi/55J/3yKfRQAzyIv8Ankn/AHyKPIi/55J/3yKfRQBBFDEUOY0PzN/CPU1J5EX/ADyT/vkUQ/cP++3/AKEafQAzyIv+eSf98ijyIv8Ankn/AHyKfRQAzyIv+eSf98ijyIv+eSf98in0UAM8iL/nkn/fIo8iL/nkn/fIp9FADPIi/wCeSf8AfIo8iL/nkn/fIrm4otU/4TX7Nb6/ez2tvCZ7qCeG3KAuSIo1KxK3ZmPzZwqj+LNSaJdXsPiC50u91G4vykCymS5tVg+fOGEWFXfGARz820kAsSaFqD0Og8iL/nkn/fIo8iL/AJ5J/wB8isDUn1Gz16yaDVZZmurgKumiGMRiED945O3eCoOd27GSq4+YCnaVrN3qXie6T5F00WytagD5pMOytIT6EjgegB/i4F08/wDK4PT+vOxu+RF/zyT/AL5FHkRf88k/75FPooAZ5EX/ADyT/vkUeRF/zyT/AL5FPooAZ5EX/PJP++RR5EX/ADyT/vkU+igBnkRf88k/75FNCIlwuxVXKNnAx3FS0w/8fCf7jfzFAD6KKKACiiigBh/4+E/3G/mKfUUhKzoQpb5W4GPUetO8xv8Ani/5r/jQA+imeY3/ADxf81/xo8xv+eL/AJr/AI0APopnmN/zxf8ANf8AGjzG/wCeL/mv+NAHLaj8PdBu9TsLqPRNMbbfy3V809urvcB45sgkglv3kitgnA28dAKk1LwJpd5YWem2trp9rYW7zOEbT47iSIyPvPkmXckYLZyCjDGANuAR0vmN/wA8X/Nf8aPMb/ni/wCa/wCNAHA6Z4P1a01yw1GTQ/D8NzDqlxe3N7DduZ5Y5vOzHn7OCdomGMtg+WOmePQaZ5jf88X/ADX/ABo8xv8Ani/5r/jQA+imeY3/ADxf81/xo8xv+eL/AJr/AI0APopnmN/zxf8ANf8AGjzG/wCeL/mv+NABH9+X/f8A/ZRT6gR23yfun+96jjge9SeY3/PF/wA1/wAaAH0UzzG/54v+a/40eY3/ADxf81/xoAfRTPMb/ni/5r/jR5jf88X/ADX/ABoAfTJ4VuLeSF2dVkUqTG5RgCMcMMEH3HNHmN/zxf8ANf8AGjzG/wCeL/mv+NAGFceE/tenXNtda3qcs1wERrs+SsojVt3ljEYUqTnOVJIJBJHFaml2Emm2f2eXULi+wfle4SJSi4ACgRoi4GPTPPWrPmN/zxf81/xo8xv+eL/mv+NAD6KZ5jf88X/Nf8aPMb/ni/5r/jQA+imeY3/PF/zX/GjzG/54v+a/40APopnmN/zxf81/xo8xv+eL/mv+NABP/wAe8n+4f5U+oJnYwSDynHynnI9PrUnmN/zxf81/xoAfRTPMb/ni/wCa/wCNHmN/zxf81/xoAfRTPMb/AJ4v+a/40eY3/PF/zX/GgB9FM8xv+eL/AJr/AI0eY3/PF/zX/GgB9FM8xv8Ani/5r/jR5jf88X/Nf8aAKcukRSfbylxcQSX23dJC+1oyqhQVOODwDzkevHFO0zTRp0cm+5mvJ5m3S3NwEDyEDAyEVVGAAOAPzJNWvMb/AJ4v+a/40eY3/PF/zX/GgB9FM8xv+eL/AJr/AI0eY3/PF/zX/GgB9FM8xv8Ani/5r/jR5jf88X/Nf8aAH0UzzG/54v8Amv8AjR5jf88X/Nf8aAH0UzzG/wCeL/mv+NHmN/zxf81/xoAB/wAfD/7i/wAzT6gDt57Hyn+6vGR6n3qTzG/54v8Amv8AjQA+imeY3/PF/wA1/wAaPMb/AJ4v+a/40APopnmN/wA8X/Nf8aPMb/ni/wCa/wCNAFfUtNh1S1S3uWcIk0U3yEDJjcOoOR0yozS6hp8WpWqwTs6qs0UwKEA7o5FcdR0yoz7VP5jf88X/ADX/ABo8xv8Ani/5r/jRsA+imeY3/PF/zX/GjzG/54v+a/40APopnmN/zxf81/xo8xv+eL/mv+NAD6KZ5jf88X/Nf8aPMb/ni/5r/jQAQ/cP++3/AKEafUETsEP7pz8zdx6n3qTzG/54v+a/40APopnmN/zxf81/xo8xv+eL/mv+NAD6KZ5jf88X/Nf8aPMb/ni/5r/jQA+imeY3/PF/zX/GjzG/54v+a/40AVrbTIba5v50eVnv5BJJlsbcIqALjBAwufXJNUrTw8baczyatf3VwsZhgmuPKLQRkqWVSEG7O1cl9x461reY3/PF/wA1/wAaPMb/AJ4v+a/40BuYyeGmj8QT6rHrWoBrhl8yArA0ZRekYJiLhOpwGHJJ6kmn2HhHQdK1g6npmlWdncGLys29vHGAM5J4UHJ6HnoBWt5jf88X/Nf8aPMb/ni/5r/jRsD1H0UzzG/54v8Amv8AjR5jf88X/Nf8aAH0UzzG/wCeL/mv+NHmN/zxf81/xoAfRTPMb/ni/wCa/wCNHmN/zxf81/xoAfTD/wAfCf7jfzFHmN/zxf8ANf8AGmhi1wuUZfkbrj1HpQBLRRRQAUUUUAMP/Hwn+438xT6Yf+PhP9xv5in0AFFFFABRRRQBhf8ACc+E/wDoaNF/8GEX/wAVWlLqllDYQ3zXKNazvEkU0fzq5ldUjwVzkFnXnpznpWaf+KnlliPGiwyvDKh63siMUdGHaJWUqQeZCCD+7H73C8a3i3EGm6vZS3v2OyupobueG4t4I4lD+VICZ2QiQlWiV0ZWUO5DchXAOoh8R6HcaodMt9Z0+W/DshtEukaUMudw2A5yMHIxxg1pV5fo/wBu/wCEo0nzP7T+x/8ACSan5fmfZfsu7F79zb++3dfv/L97/Zr1CgAooooAKKKKAGR/fl/3/wD2UU+mR/fl/wB//wBlFPoAKKKKACiiigAoJAGScAUVDdmFbKc3UfmwCNvMTyzJuXHI2gEtx2AOaTGitb67pF3p81/aarZT2cGRNcxXCNHHgZO5gcDAIPNWbO9tdQtEurC5hureQZSaCQOjc44I4NcDPeWd5capqNvqenXtpF9klS5t/ltofKmLJDKy78H5stJ0UEEqAOeh8ITXN4NV1C4ktnivLwSQG0lMsJUQxqSj4G4blYZwMkHiqWt/67f18vMXU6OiiikAUUUUAFFFFADJ/wDj3k/3D/Kn0yf/AI95P9w/yp9ABRRRQAUUUUAFFFFABRRRQBUu9V07T7i3t7+/tbWa6bZBHNMqNM2QMKCcsckcD1FW65Pxvd6emn3Ni99ZWV9d2xjxcxfPdR/MPKiYkZck8Y37SwO05FdRA7SW0bvGY2ZASjHJU46ULYHoySiiigAooooAKKKKACiiigBg/wCPh/8AcX+Zp9MH/Hw/+4v8zT6ACiiigAooooACQBknAFULnXtIshbG81Wytxd/8exluEXzun3Mn5uo6eoqj4sN8+mx21np1zfQTuVuxbSRK4iAJI/eOo+Y4U4OcE+1cv8A8JDpMHg3SdJv5LPS7/UtLSF21CWFPKt9pUux3YYHJ2oCSS3IA3EJa3/rv/X3jPRaKitVjS0hWGTzIwihHLbtwxwc9/rUtU9yVqgooopDCiiigBkP3D/vt/6EafTIfuH/AH2/9CNPoAKKKKACiiigAooooAqRarp0+pTafBf2sl7AN0tskymSMccsoOR1HX1FJp+saZqxlGl6jaXpgO2UW06yeWfRtpOOh6+lcXbXG7XLXTILnT3tdO1G5ubvbM3nqjJOW86EqNi7pANxLBuGGM1f8P8AiDQ9b1ibVrPVNPSCC2Fvb28dzHvEW4fvJFB+QE7QqnBAJzgttUWv9f1/WvQHp/X9ep07app6aoumtfWy37p5i2pmXzWXn5gmc44POO1Jbatp15ez2dpqFrPdWxxPBFMrPF/vKDkfjXGajeCLxHNarcW6zTanFKmmGT/S5WARROp3cRALkrtPCsdw6B/g2XZc6Vaf2kmo3UNiUvLdkjD6a4CZXhd67mByHJLbc9qFqr/1t/X/AANgejsd3RRRQAUUUUAFFFFABTD/AMfCf7jfzFPph/4+E/3G/mKAH0UUUAFFFFADD/x8J/uN/MU+opAWnQBivytyMeo9ad5bf89n/Jf8KAH0Uzy2/wCez/kv+FHlt/z2f8l/woAfRTPLb/ns/wCS/wCFHlt/z2f8l/woAyZ/CmmT3EkwbULcyuXZLTU7m3j3E5YhI5FUEkkkgckknJJNT2Ph7StPS1W3skZ7N5Xt5pyZpY2lYtIRI5LZYscnPOav+W3/AD2f8l/wo8tv+ez/AJL/AIUAYNt4H0S0uLeeFdQ321wbmIPqt06rKSxZ9rSEEne+cjnc2c5NdDTPLb/ns/5L/hR5bf8APZ/yX/CgB9FM8tv+ez/kv+FHlt/z2f8AJf8ACgB9FM8tv+ez/kv+FHlt/wA9n/Jf8KACP78v+/8A+yin1AiNvk/ev970HPA9qk8tv+ez/kv+FAD6KZ5bf89n/Jf8KPLb/ns/5L/hQA+imeW3/PZ/yX/Cjy2/57P+S/4UAPopnlt/z2f8l/wo8tv+ez/kv+FAD6KZ5bf89n/Jf8KPLb/ns/5L/hQA+imeW3/PZ/yX/Cjy2/57P+S/4UAPopnlt/z2f8l/wo8tv+ez/kv+FAD6KZ5bf89n/Jf8KPLb/ns/5L/hQAT/APHvJ/uH+VPqCZGEEh81z8p4wPT6VJ5bf89n/Jf8KAH0Uzy2/wCez/kv+FHlt/z2f8l/woAfRTPLb/ns/wCS/wCFHlt/z2f8l/woAfRTPLb/AJ7P+S/4UeW3/PZ/yX/CgB9FM8tv+ez/AJL/AIUeW3/PZ/yX/CgB9FM8tv8Ans/5L/hR5bf89n/Jf8KAH0Uzy2/57P8Akv8AhR5bf89n/Jf8KAH0Uzy2/wCez/kv+FHlt/z2f8l/woAfRTPLb/ns/wCS/wCFHlt/z2f8l/woAfRTPLb/AJ7P+S/4UeW3/PZ/yX/CgAH/AB8P/uL/ADNPqAI3nsPNf7q84HqfapPLb/ns/wCS/wCFAD6KZ5bf89n/ACX/AAo8tv8Ans/5L/hQA+imeW3/AD2f8l/wo8tv+ez/AJL/AIUAPopnlt/z2f8AJf8ACjy2/wCez/kv+FAD6KZ5bf8APZ/yX/Cjy2/57P8Akv8AhQA+imeW3/PZ/wAl/wAKPLb/AJ7P+S/4UAPopnlt/wA9n/Jf8KPLb/ns/wCS/wCFABD9w/77f+hGn1BEjFD+9cfM3Yep9qk8tv8Ans/5L/hQA+imeW3/AD2f8l/wo8tv+ez/AJL/AIUAPopnlt/z2f8AJf8ACjy2/wCez/kv+FAD6KZ5bf8APZ/yX/Cjy2/57P8Akv8AhQA+imeW3/PZ/wAl/wAKPLb/AJ7P+S/4UAPopnlt/wA9n/Jf8KPLb/ns/wCS/wCFAD6KZ5bf89n/ACX/AAo8tv8Ans/5L/hQA+imeW3/AD2f8l/wo8tv+ez/AJL/AIUAPopnlt/z2f8AJf8ACjy2/wCez/kv+FAD6Yf+PhP9xv5ijy2/57P+S/4U0KVuFy7N8jdceo9KAJaKKKACiiigBh/4+E/3G/mKfTD/AMfCf7jfzFPoAKKKKACiiigDC/t641H/AEjw1DDqVjD80k6yjbc+scDZ2sw6lidm4BM5LtESeKdMm+xfYNY0wST3QgNvdTeXI54DxBSdyyrvQ7CpOcKQpbcvEXPhu41nUr++1bQNWurh724RZo9P0gq0SSskWDOvmEeWqct16jIxW9b2WtXfw4tbZLJzf2upRmG2uxHbEQwX4KBvLXYoEUa8oCCBlQ2RkA6SDUZpfFV9pjKnk29lbXCMAdxaR51YHnGMRLjjufw0q4zSPBmk2fjK5mk8P6Yvk2Fk8U8OnJFGLgSXBdoxztbiM8EkDZkng12dABRRRQAUUUUAMj+/L/v/APsop9Mj+/L/AL//ALKKfQAUUUUAFFFFABVfUb6LTNMur+4DGK1heZwgydqgk49+KsVFdRGezmhAjJkjZQJU3ocjHzLkZHqM0nsNWvqZNrr1ynnx6zYLb3MUIuFhspHui8ZJHHyKd2RyACOQc9cXdG1E6tpEF81u1s0oOYXYMUIJGCRxnjt+tZPhnw9Npt5PfX0McNxJEkAVL6a8+VSWz5koDAEtwnQY68nGto1lJp2kxWs7KzoXJKEkcsT3+tMnW5eooooGFFFFABRRRQAyf/j3k/3D/Kn0yf8A495P9w/yp9ABRRRQAUUUUAFFFFABSMSqEhSxAyFGMn25pabIXETmEK0m07QxwCe2TzgUnsCMKLXNWF1LZXejwJfNb/aLaKG98xXAYKQ7FF2EFlzgNxnGSMG3o+qXF9JeW2oWkVreWcipIkM5mjIZQylXKqTweQVGCPTBONYWXiy2s9QnltNHbWLlARdG+ldGYHhNvkgpGoLEAFjnrksWrW8N2d9Y6e8OpW1vFMX3tLFdtcNOx+87sYo8MfQDAGAMAACgNeiiikAUUUUAFFFFABRRRQAwf8fD/wC4v8zT6YP+Ph/9xf5mn0AFFFFABRRRQBlz60IvEVtpS2c7ecrM1yVKxqQuQoJ+8Tz04Hcg4BgtPEE2oR6p9i0u4Mtk4SGK4PkmclQQcNyi5PcZwM46A3buykuNW0+6RlCWxkLgk5O5cDFQfYb+3udVurJrYzXJjaBZt23KoAQ2ORnB5GcZzg9Kl3Bbj9G1OfUBdxXttHbXdnN5MyQzedHkorgq5VSflcdVBBz2wTpVi+HNJn0wXUk1taWAuHDLY2Ll4YiBywJRPmYnJ+UduvU7VUAUUUUAFFFFADIfuH/fb/0I0+mQ/cP++3/oRp9ABRRRQAUUUUAFFFFAHPxeJ5DfgXFiIrCWaeCGYSkyl4d+8tHsAVf3bYIYk/LwM8P0fXry9vo7fU9PgszdW32q1MV0Zi6AgMGBRdrDenA3DnrxWbH4UvDrLPJHaRxtJK0+opKWur2N1cCGRSgAVd4x87AeWuAO1nS9L1qK8trrULfT1ksLI2cCwXUjCbcyFmYmMbOIxgAN1PI7i31/rf8A4APy/rb/AIJKvidpfGEuiQDTR5LBXE2obLl/kDkpD5Z3AAjncOh9KsWGs30usiw1TTY7NpoXnt/LufNYojKp8wbQEb51wAXHXnjmK60zUbrUGgMFhFYPdR3ZuYZGSdmQqwVk24YkoAW3jj+HimadpGof8JGdT1C2061kEZSWexdt190CmRSg2hQOBufGcZ45F0v/AF/TB9ToaKKKACiiigAooooAKYf+PhP9xv5in0w/8fCf7jfzFAD6KKKACiiigCKR1SdC7BRtbknHcU7z4v8Anqn/AH0KfRQAzz4v+eqf99Cjz4v+eqf99Cn0UAM8+L/nqn/fQo8+L/nqn/fQp9FADPPi/wCeqf8AfQo8+L/nqn/fQp9FADPPi/56p/30KPPi/wCeqf8AfQp9FADPPi/56p/30KPPi/56p/30KfRQAzz4v+eqf99Cjz4v+eqf99Cn0UAQJNEHkzInLcfMPQVJ58X/AD1T/voU+igBnnxf89U/76FHnxf89U/76FPooAZ58X/PVP8AvoUefF/z1T/voU+igBnnxf8APVP++hR58X/PVP8AvoU+igBnnxf89U/76FHnxf8APVP++hT6KAGefF/z1T/voUefF/z1T/voU+igBnnxf89U/wC+hR58X/PVP++hT6KAGefF/wA9U/76FHnxf89U/wC+hT6KAIJpojBIBIhJU8bh6VJ58X/PVP8AvoU+igBnnxf89U/76FHnxf8APVP++hT6KAGefF/z1T/voUefF/z1T/voU+igBnnxf89U/wC+hR58X/PVP++hT6KAGefF/wA9U/76FHnxf89U/wC+hT6KAGefF/z1T/voUefF/wA9U/76FPooAZ58X/PVP++hR58X/PVP++hT6KAGefF/z1T/AL6FHnxf89U/76FPooAZ58X/AD1T/voUefF/z1T/AL6FPooAZ58X/PVP++hR58X/AD1T/voU+igCATReex8xMbV53D1NSefF/wA9U/76FPooAZ58X/PVP++hR58X/PVP++hT6KAGefF/z1T/AL6FHnxf89U/76FPooAZ58X/AD1T/voUefF/z1T/AL6FPooAZ58X/PVP++hR58X/AD1T/voU+igBnnxf89U/76FHnxf89U/76FPooAZ58X/PVP8AvoUefF/z1T/voU+igCCKaIIcyIPmb+IepqTz4v8Anqn/AH0KfRQAzz4v+eqf99Cjz4v+eqf99Cn0UAM8+L/nqn/fQo8+L/nqn/fQp9FADPPi/wCeqf8AfQo8+L/nqn/fQp9FADPPi/56p/30KPPi/wCeqf8AfQp9FADPPi/56p/30KPPi/56p/30KfRQAzz4v+eqf99Cjz4v+eqf99Cn0UAM8+L/AJ6p/wB9Cjz4v+eqf99Cn0UAM8+L/nqn/fQo8+L/AJ6p/wB9Cn0UAM8+L/nqn/fQpodHuF2MrYRs4Oe4qWigAooooAKKKKAP/9k="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.卡方独立性检验：\n",
    "\n",
    "如两组大白鼠在不同致癌剂作用下的发癌率如下表，问两组发癌率有无差别？\n",
    "![20201229172329838.JPG](attachment:20201229172329838.JPG)\n",
    "我们假设发病率没有差别。那么根据没有差别取计算期望值。这时候发病率我们不看，因为我们假设他们是一样的。那么甲组发病数应该是(91/113)*71,甲组不发病为71-(91/113)*71,乙组也是类似。\n",
    "\n",
    "然后根据公式计算残差平方除以期望再求和。得到统计量。这种计算就不算了。\n",
    "我们用Python的库来方便计算他们。\n",
    "————————————————\n",
    "版权声明：本文为CSDN博主「PY_smallH」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。\n",
    "原文链接：https://blog.csdn.net/PY_smallH/article/details/111881468"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats.chi2_contingency(np.array([[52,19],[39,3]]),correction=False)\n",
    "  # stats.chi2_contingency：\n",
    "  #   （1）四个返回值。第一个是统计量，第二个是p值，第三个是自由度，第四个是期望，就是我们上面算的那个期望值。\n",
    "  #   （2）correction=True：默认是True，使用修正。对于样本总频数大于40，且样本期望频数小于5且大于等于1，使用连续修正值的卡方检验。\n",
    "  #        correction=False：不使用修正，平时用的Pearson公式。对于样本总频数大于40，且样本期望频数大于等于5，使用Pearson卡方值。\n",
    "  #   （3）out: (6.477664689435311, 0.010923841556032656, 1, array([[57.17699115, 13.82300885],\n",
    "  #                                                                [33.82300885,  8.17699115]]))\n",
    "  #   （4）H0：发病率无差别。p = 0.0109，拒绝。发病率有差别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 最小二乘法（least sqaure method）\n",
    "\n",
    "最小二乘法的主要思想是通过确定未知参数（通常是一个参数矩阵），来使得真实值和预测值的误差（也称残差）平方和最小\n",
    "\n",
    "![](https://pic4.zhimg.com/80/v2-03371751ad88764e64216b921f93d403_1440w.jpg)\n",
    "\n",
    "![](https://pic4.zhimg.com/50/v2-0bbff14fc4305c9f66d84ea5de78beb4_hd.webp?source=1940ef5c)\n",
    "\n",
    "[最小二乘法解释和Python实现](https://zhuanlan.zhihu.com/p/38128785)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn\n",
    "  # Seaborn是一个比Matplotlib集成度更高的绘图库。\n",
    "  # 官网教程：http://seaborn.pydata.org/generated/seaborn.pairplot.html#seaborn.pairplot\n",
    "x = np.linspace(-5, 5, 20)\n",
    "  # 创建数值序列工具。均匀间隔创建数值序列。\n",
    "  #   （1）np.linspace(start = 0, stop = 100, num = 5)。起始点、终止端，以及指定分隔值总数（包括起始点和终止点）。\n",
    "\n",
    "np.random.seed(1)\n",
    "  # 用于生成指定随机数。\n",
    "  #   （1）种子np.random.seed(1)确定以后，该种子对应的随机数序列也就确定下来了。\n",
    "  #   （1）只调用一次seed()，两次的产生随机数不同。\n",
    "  #        调用两次seed()，两次产生的随机数相同。\n",
    "\n",
    "y = -5 + 3*x + 5 * np.random.normal(size=x.shape)\n",
    "  # normal distributed noise\n",
    "\n",
    "data = pd.DataFrame({'x': x, 'y': y})\n",
    "  # Create a data frame containing all the relevant variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x2208b6a9b00>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.plot('x', 'y', kind = 'scatter')\n",
    " # plt.plot(x, y)：\n",
    " # kind = 'scatter'：指定具体图形类型：散点图。\n",
    " # df.plot.scatter() # 散点图。均可。\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {
    "20210315170350171.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### statsmodels API\n",
    "\n",
    "statsmodels是Pandas生态系统（ecosystem）下Statistics and Machine Learning下的一个库。主要是偏传统频率学派统计方法，具体有下面三大主题组成。\n",
    "官网：https://www.statsmodels.org/stable/api.html\n",
    "安装：pip install statsmodels\n",
    "\n",
    "1、statsmodels.api：横截面模型和方法。\n",
    "2、statsmodels.tsa.api：时间序列模型和方法。\n",
    "3、statsmodels.formula.api：使用公式字符串和DataFrame指定模型的方便接口。API支持直接使用from_formula导出该类下的模型。\n",
    "————————————————\n",
    "版权声明：本文为CSDN博主「条件漫步」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。\n",
    "原文链接：https://blog.csdn.net/chenhepg/article/details/114838953\n",
    "\n",
    "\n",
    "3、statsmodels.formula.api\n",
    "使用公式字符串和DataFrame指定模型的方便接口。API支持直接使用from_formula导出该类下的模型。\n",
    "![20210315170350171.png](attachment:20210315170350171.png)\n",
    "https://www.statsmodels.org/stable/example_formulas.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   R-squared:                       0.804\n",
      "Model:                            OLS   Adj. R-squared:                  0.794\n",
      "Method:                 Least Squares   F-statistic:                     74.03\n",
      "Date:                Sun, 20 Dec 2020   Prob (F-statistic):           8.56e-08\n",
      "Time:                        00:55:19   Log-Likelihood:                -57.988\n",
      "No. Observations:                  20   AIC:                             120.0\n",
      "Df Residuals:                      18   BIC:                             122.0\n",
      "Df Model:                           1                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "Intercept     -5.5335      1.036     -5.342      0.000      -7.710      -3.357\n",
      "x              2.9369      0.341      8.604      0.000       2.220       3.654\n",
      "==============================================================================\n",
      "Omnibus:                        0.100   Durbin-Watson:                   2.956\n",
      "Prob(Omnibus):                  0.951   Jarque-Bera (JB):                0.322\n",
      "Skew:                          -0.058   Prob(JB):                        0.851\n",
      "Kurtosis:                       2.390   Cond. No.                         3.03\n",
      "==============================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\statsmodels\\compat\\pandas.py:49: FutureWarning: The Panel class is removed from pandas. Accessing it from the top-level namespace will also be removed in the next version\n",
      "  data_klasses = (pandas.Series, pandas.DataFrame, pandas.Panel)\n"
     ]
    }
   ],
   "source": [
    "from statsmodels.formula.api import ols\n",
    "  # 数学模型导入\n",
    "model = ols(\"y ~ x\", data).fit()\n",
    "print(model.summary())\n",
    "  # 官网例子：mod = smf.ols(formula='Lottery ~ Literacy + Wealth + Region', data=df)\n",
    "  #           res = mod.fit()\n",
    "  #           print(res.summary())\n",
    "  # categorical variable：C() \n",
    "  #           res = smf.ols(formula='Lottery ~ Literacy + Wealth + C(Region)', data=df).fit()\n",
    "  # Multiplicative interactions：\n",
    "  #          “:” adds a new column to the design matrix with the product of the other two columns. \n",
    "  #          “*” will also include the individual columns that were multiplied together.\n",
    "  # Removing variables:\n",
    "  #           The “-” sign can be used to remove columns/variables.\n",
    "  # https://www.statsmodels.org/stable/example_formulas.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simple_ols(y,x):\n",
    "    import scipy\n",
    "    x = scipy.c_[np.ones(x.shape[0]),x]\n",
    "      #  拓展第一列，用来和截距做内积.\n",
    "      # （1）x.shape[0]：把样本量读出来，n。\n",
    "      #     array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,。。。1., 1., 1.])\n",
    "      # （2）[np.ones(x.shape[0]),x]：1列20个1,1列x。\n",
    "      # （3）scipy：有效计算Numpy矩阵，使Numpy和Scipy协同工作，高效解决问题。\n",
    "      #  线性模型（线性回归，logistic回归）公式推导+numpy实现：https://blog.csdn.net/qq_33154865/article/details/103839352\n",
    "    \n",
    "    inv_xx = scipy.linalg.inv(np.dot(x.T,x))\n",
    "      # （1）.dot（）：dot函数为numpy库下的一个函数，主要用于矩阵的乘法运算.\n",
    "      #     x.dot(y) 等价于 np.dot(x,y) ———x是m*n 矩阵 ，y是n*m矩阵，则x.dot(y) 得到m*m矩阵。\n",
    "      #     结果：(1*n)*(n*1)=1*1。例子：184.21052631578948。\n",
    "      # （2）scipy.linalg：线性代数计算。\n",
    "      #      linalg.inv（）：矩阵求逆。\n",
    "        # b = inv(x.T * x)*x.T*y\n",
    "    b = np.dot(inv_xx, np.dot(x.T,y)) \n",
    "    \n",
    "    nobs = y.shape[0]\n",
    "      #  number of observations\n",
    "      #      y.shape：(20,)\n",
    "      #      y.shape[0]：20\n",
    "    ncoef = x.shape[1]                    \n",
    "      #  number of coef.\n",
    "      #      x.shape：(20, 2)\n",
    "    df_e = nobs - ncoef              \n",
    "      #  degrees of freedom, error \n",
    "    df_r = ncoef - 1                      \n",
    "      #  degrees of freedom, regression \n",
    "    e = y - np.dot(x,b)                              # residuals\n",
    "    sse = np.dot(e,e)/df_e                           # Sum Squared Error，误差平方和\n",
    "    se = np.sqrt(np.diagonal(sse*inv_xx))            # coef. standard errors\n",
    "      #  np.diagonal（）：查看矩阵对角线上的元素\n",
    "      #  np.sqrt（）：开平方。\n",
    "    t = b / se                                       # coef. t-statistics\n",
    "    p = (1-scipy.stats.t.cdf(abs(t), df_e)) * 2      # coef. p-values\n",
    "      #  cdf：累积分布函数，已知x位置求累计概率。\n",
    "    R2 = 1 - e.var()/y.var()                         # model R-squared\n",
    "    R2adj = 1-(1-R2)*((nobs-1)/(nobs-ncoef))        # adjusted R-square\n",
    "    F = (R2/df_r) / ((1-R2)/df_e)                   # model F-statistic\n",
    "    Fpv = 1-scipy.stats.f.cdf(F, df_r, df_e)        # F-statistic p-value\n",
    "    res = {'b':b, 'SSE': sse, 'SE': se, 't':t, 'p':p, 'r2':R2, 'r2adj':R2adj, 'F':F, 'Prob(F)': Fpv}\n",
    "    return res\n",
    "\n",
    "b = simple_ols(y,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': array([-5.53345855,  2.93688832]),\n",
       " 'SSE': 21.46274053808336,\n",
       " 'SE': array([1.03592327, 0.34133857]),\n",
       " 't': array([-5.34157181,  8.60403296]),\n",
       " 'p': array([4.45960678e-05, 8.56064915e-08]),\n",
       " 'r2': 0.8044102939875739,\n",
       " 'r2adj': 0.7935441992091058,\n",
       " 'F': 74.02938317651765,\n",
       " 'Prob(F)': 8.560649156219569e-08}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b\n",
    "  # 结果：{'b': array([-5.66682318,  2.92111039]), 'SSE': 33.53553209075524, \n",
    "  #        'SE': array([1.29490409, 0.42667321]), 't': array([-4.37624935,  6.84624743]), \n",
    "  #        'p': array([3.64101866e-04, 2.08848570e-06]), 'r2': 0.7225266888533326, \n",
    "  #        'r2adj': 0.7071115049007399, 'F': 46.87110391127139, 'Prob(F)': 2.0884856961611575e-06}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x23f3b878080>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "seaborn.lmplot(y='y', x='x', data=data)\n",
    "  # lmplot 是一种集合基础绘图与基于数据建立回归模型的绘图方法。\n",
    "plt.show()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:31: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support skipfooter; you can avoid this warning by specifying engine='python'.\n"
     ]
    }
   ],
   "source": [
    "# Standard library imports\n",
    "import urllib.request       # 向网页发送请求\n",
    "import os                   # 整理文件和目录最为常用的模块\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import pandas\n",
    "\n",
    "if not os.path.exists('wages1.txt'):\n",
    "    # os.path.exists（）：  判断路径是否存在，这里的路径包括目录和文件\n",
    "    # urllib.request.urlretrieve('http://lib.stat.cmu.edu/datasets/CPS_85_Wages','wages.txt',engine='python')\n",
    "    urllib.request.urlretrieve('http://lib.stat.cmu.edu/datasets/CPS_85_Wages',\n",
    "                               'F:/hongdou/1111111111111111课程/Python/python_course-master/ProgramSession/wages1.txt')\n",
    "    # 地址：F:\\hongdou\\1111111111111111课程\\Python\\python_course-master\\ProgramSession\n",
    "    # Download the file if it is not present\n",
    "    #      urlretrieve()： 方法直接将远程数据下载到本地。\n",
    "    #      urllib.request.urlretrieve(url, filename=None, reporthook=None, data=None)\n",
    "    #     （1）filename：  指定了保存本地路径（如果参数未指定，urllib会生成一个临时文件保存数据。）\n",
    "    #     （2）reporthook：是一个回调函数，当连接上服务器、以及相应的数据块传输完毕时会触发该回调，我们可以利用这个回调函数来显示\n",
    "    #                      当前的下载进度。\n",
    "    #     （3）data：      指post导服务器的数据，该方法返回一个包含两个元素的(filename, headers) 元组，\n",
    "    #                      filename 表示保存到本地的路径，header表示服务器的响应头。\n",
    "\n",
    "# Give names to the columns\n",
    "names = [\n",
    "    'EDUCATION: Number of years of education',\n",
    "    'SOUTH: 1=Person lives in South, 0=Person lives elsewhere',\n",
    "    'SEX: 1=Female, 0=Male',\n",
    "    'EXPERIENCE: Number of years of work experience',\n",
    "    'UNION: 1=Union member, 0=Not union member',\n",
    "    'WAGE: Wage (dollars per hour)',\n",
    "    'AGE: years',\n",
    "    'RACE: 1=Other, 2=Hispanic, 3=White',\n",
    "    'OCCUPATION: 1=Management, 2=Sales, 3=Clerical, 4=Service, 5=Professional, 6=Other',\n",
    "    'SECTOR: 0=Other, 1=Manufacturing, 2=Construction',\n",
    "    'MARR: 0=Unmarried,  1=Married',\n",
    "]\n",
    "\n",
    "short_names = [n.split(':')[0] for n in names]\n",
    "    # .split（）：分割。\n",
    "    #       结果：['EDUCATION', 'SOUTH', 'SEX', 'EXPERIENCE', 'UNION', 'WAGE', 'AGE', 'RACE', 'OCCUPATION', 'SECTOR', 'MARR']。\n",
    "data = pandas.read_csv('wages.txt', skiprows=27, skipfooter=6, sep=None,header=None)\n",
    "data.columns = short_names\n",
    "\n",
    "data['WAGE'] = np.log10(data['WAGE'])\n",
    "    # np.log10（）：10为底。\n",
    "    # np.log（）：e为底。log下什么都不写默认是自然对数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x23f3b6744e0>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn\n",
    "  # Seaborn是一个比Matplotlib集成度更高的绘图库。\n",
    "seaborn.lmplot(y='WAGE', x='EDUCATION', data=data)\n",
    "  # lmplot 是一种集合基础绘图与基于数据建立回归模型的绘图方法。\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.PairGrid at 0x23f3accca20>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg8AAAIUCAYAAACdNM/6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXt0ZNV95/vZ51EvVenVklpNP6AF3WkMbscY2zAhuMcmMdi5OMklM5CbZDwTBzLLDh4nzjLJwk6GJCt4xSseSLImTUhuJsm64AwzjplrcBKb22kzAQMGA43p0Fjd0OqX3lK9z2vfP/Y5R1WqlySkllrsz1paUp2qOrWrdGrv3/49vj8hpUSj0Wg0Go1mqRjrPQCNRqPRaDQXFtp40Gg0Go1Gsyy08aDRaDQajWZZaONBo9FoNBrNstDGg0aj0Wg0mmWhjQeNRqPRaDTLQhsPGo1Go9FoloU2HjQajUaj0SwLbTxoNBqNRqNZFhec8XDjjTdKQP/on2Y/646+PvVPm591R1+f+qfNz7K44IyHycnJ9R6CRtMSfX1qNjL6+tSsFhec8aDRaDQajWZ90caDRqPRaDSaZaGNB41Go9FoNMtCGw8ajUaj0WiWhTYeNBqNRqPRLAtrvQegeWtcctfXl/S4E/d+dI1HolltDh0d5+DhUU7OlNjZl+GO60c4sG9ovYel0WiWyGb+DmvPg0azATl0dJwvPPoK4/kKvWmb8XyFLzz6CoeOjq/30DQazRLY7N9hbTxoNBuQg4dHsU1BJmEhhPptm4KDh0fXe2gajWYJbPbvsDYeNJoNyMmZEmnbrDuWtk3GZkrrNCKNRrMcNvt3WBsPGs0GZGdfhrLr1x0ruz47+jLrNCKNRrMcNvt3WBsPGs0G5I7rR3B9ScnxkFL9dn3JHdePrPfQNBrNEtjs32FtPGg0G5AD+4a45+YrGMqlmCu7DOVS3HPzFZsmU1uj2exs9u+wLtXUaDYoB/YNbZqJRqN5O7KZv8Pa86DRaDQajWZZaONBo9FoNBrNstDGg0aj0Wg0mmWxZjkPQoi/AH4CGJdSXtnk/gPA14Dj4aH/KaW8Z63GcyGxVMlpjUaj0WjWg7VMmPxL4I+Bv2rzmG9LKX9iDceg0Wg0Go1mlVmzsIWU8jAwvVbn12g0Go1Gsz6sd87DtUKIF4UQjwshrljnsWg0Go1Go1kC66nz8DxwsZSyIIT4CPB3wJ5mDxRC3A7cDrBr167zN8JNxHLyKHT77uWhr0/NRkZfn5q1YN08D1LKeSllIfz7McAWQgy0eOwDUsqrpZRXDw4OntdxajSd0NenZiOjr0/NWrBuxoMQYlgIIcK/3xeOZWq9xqPRaDQajWZprGWp5kPAAWBACDEG/BZgA0gp/xS4BfiPQggPKAO3SinlWo1Ho9GcHw4dHefg4VFOzpTY2ZfhjutHzrtE70YYg0az2tfhRrqu18x4kFLe1uH+P0aVcmo0mmWykSaRxeP6wqOvYJuC3rTNeL7CFx59hXvgvI1vI4xBozl0dJzPPvIihaqHH0gmC1U++8iLfOmWd63oOtxo17VujKXRXGB0mkQiw+LYeB7HC7BNwd6t3WtuYBw6Os6dD79AoeKBACEEKcsgl7I4eHh0zV47er+vnZvH9SVlx8c0BVtzKURCkElYlBxvTceg0Szm3sdfZbbkYgqBKQQygNmSy72Pv9r2Orz/m6/x4JPHKTo+XQmTT1y3mztv2MvBw6NM5iuU3CB+bMY2OHh4FOC8bya08aDRXGAcPDyKbapFEahbHAG+8OgruL7PXMkFAWUXjk8W1nSXEhk0+YqHBJCAlFS9AKfo4Pnzq/6ata/reD7zFQ8AN5BIJKfnygB0p23StsnYTGlNxqDRNOP4VAlDgGEIAIQAGUiOT7W+Du//5mvc98TrGAIsA8quz31PvA7A829OUfXqH19yA547McWp2fJ590ist86DRqNZJidnSqRts+5YtDhGhsV82cMwBJZhYCDIVzxsU8QGxmoTva5KgVYTpQCCMI3J8ZeXznTo6Di3PfA0133xCW574GkOHR1v+7r5ioeBer8C8CUYCCYLVUBNwjv6Mit9exrNeeHBJ4+HhoOBIYzwtzq+2HCIcAPizYQQ6vdaftcjtOdBo7nA2NmXYTxfiT0PsLA4npwp0Zu2cfwAs2bH4/hBy933SsIctTkX2YTJ6xNFhIAgshHC34EEU0LCUvuUVi7Zxedeamy37v2GlottChxfeR8cX1JyPFxfcsf1Ix0/23a5JBs1z0Sz9qzkfz8y0MWx8QJCSuV1kOr7sGewq+X5io6PDCSu78fnMYCi9Fu/EHB6pki5xrhIW+B4QesnrALaeNBoLjDuuH6ELzz6CiXHI22blF0/XhwPHh5lPF8hYRp4wcKklTCNprvvaKFuFea4ZWyWp0an6yY5IF7cTQGvTxTxAokZehskse2AIWAgl+CSLdm2LtlaA6JdWGbxhB0ZUgnTwPPV+1W5FsqQkMBQLrWkyb6d0VL7njdCsprm/LHSRMXP3biPOx96noLjE0j1XcgmTG66crjl+UzAWXSeAEgA7cyHstd4e6ZYXcnbXTLaeNBoLjAO7BviHtQiOzZTYseindAXHn2F7rTFZN4hEGoZz6XsprvvaKGeKqgwhyEEQSDJVzxyKfiTQz9gR1+6bpLL2Ea8uI9OFDCFQJjg+RLTEMpoASxDMJBLYJsmd1w/wp0PvxC7ZEFNpl4Q8OCTx+uMh8ibUEut12Sx12O+7JJLWUwVHYJAgiR+3XtuvmLJi3unXJKlGjSazUUnY7adVyJpmzi+xAsCLMMgaZs89vKZlucTRq37bgFhCDKWQclp74GopeBoz4NGo1nEgX1DDYtWNIkVqy6uL0knVF5EwhTsHsg23X23C3PkKx5eEJBJWMyXXSYLVapegC8lu/rSAHG4wBQCKSFpGUhX7bR6MjaXbMnWuWStRVlWhoDiogmxXVjm0NFxfv2RF+OxWYZBwhRs78vg+QGOL0lYRt3rLpV2RouEtgaNZvNycqaEKWB0ooDjByRMg4FsgrGZUluvxMHDo3SnbYZ70vG5So7H8akSe4ayda8RXUuR4V1rPgjACyRX7erjhTdnqNSEI1KWUXf7fKKNB41mE1A7iW3rScehjFY778jQmMhXmSxUMVDhjdowR9ULSJoG82WX03NlDASmAZ4Hp2YrgIjDBaAMh5HBLJOFCsWqT6omqTNKeKx6ksgBawj1el2J+mmoWVhmvuxiG4Jf+qvnVIjEAMs0kJK4dO25z//4W/oM2xktACemCsyXvXgB6U5bXLIl2+p0mnVmtXJUsgmTo+cK8W3X9ylOl9m3NdvWK9HK6AB1XTW7zqYKDqWg3piWQNI0uHakn2dOTGObgshB4TbxUpwvdLWFRrMJqJ3EClWPs3MVTs2WuPPhFxoqFSJDYzxfYbg7iedLvECVVVZcn6of4PoBIOnJ2KFxIcKSM6XdAHAuX2Egm8CXEj+QDGQTTBYqjOcdMgkz3ol99pEX+fVHXiQd5iFEBBL8AD60r77fwoF9Q9xz8xUM5VLMlV0SpoFETZSqDBO8AHxfYgg1kY5OFt/yZ3jH9SO4YYKllPWJlteO9DOed3D8ACP0zIznHa4d6X/Lr6tZfWqv8VqPQKuqnXZM5JvnDkzkq20rn3JJi1OzldDYVeG8U7MVhnLJltdZ2m6+JKdtg6dGpxnMJkiYBkFo4A9mE3F+z2L2be1a9ntdDtp40Gg2AdEklq+4nA4nLMsQlBy/YdKsNTS60wl29KXjkAWAKcAQgq6khesrowIhCUIjAVQJZtUNKDo+lw12sWcoSyChWPUZzCYYzKXisrFC1Qv1H0TDhNObtjg7vzhFTBkQD91+Dd/+3AfpzSToSduqFA3lxgXwV1nNfrHRMpRLxZ6bVhP3U6PTqzoGzepQe42/1fLF6ZLb8vjOvgxlt95TEHkR4m4Lkros4q6E2fI6m6s0r8ecr3icnCkxkE0yMphl33A3I4NZBrJJJAJz0eNNoK8rtez3uhx02EKj2QRELveJfBURLv5BAElLxJNm5LJt5k4VKKMhZZtx/oPyHiRwvICi42EbQhkNvkSG2eMAd910eXzu6774RENugB9IpJT4UpCwDQQivC3Z0ZfpmDdQm4uQrInxBhKCQBJIuGxgdTQcmuWSRGMYyCYZzC1MyFJKnfOwQemUdLscWpmokvaVT3d/7Qh9GYupohtXW2zpsik6fsvrLDLORY0zQUqV87CzL9M0dOYHEilAqFxhlTMh4Ni5tRFmi9CeB41mExC53CueD0i1qCIZyCYbJs1m7tSqL/HDSSo6Npl3mChUuf/Wd7O9N0Mg1UIdbagMlNzu3V99KRZ0ihIrazFDsapEmKMA7ctHF1O7uxvuSWFFiZ2AMKA3Y3PXTZfXPWepIlNLfWy7HaZm47Ga/6/mQQF1/MC+IW65ajsT+Sqvns0zka9yy1XbObBviFzSYqbkYZsGKdvANg1mSh7ZZOs9u2WGJcZy4Sc63ip0FhnQtRIrgWxMRF5ttPGg0WwCIpd7V8LCD9Rkc1FPmu60TdlVgkzRAnliqqhcqovcqaA8FgJVsomAUtWPKzgilUhDgG0IbMtUu++5ahxb7kqaTBQcJvKVOJ6bTVrkUhbdaYsgUGVrAZJcylqSeFNtLkI2aTGYS5C0DLJJZZCAclNHi/5y4t1LfWy7fAjNxmM1/1/be5Itjx86Os4jz59iMJfk8uEcg7kkjzx/ikNHx1uGLaSULQ3Wrbnmr7U1l2wZOmtVa7HWIlHaeNBoNgkH9g1x/63v5qLeNMM9KXIplfk9V3aZKjrxAumGYQchVN5AtNsBFQaQMvRcSEnZ9RnPV9hWU25mCoEVLtpRsncUWx7IpuhJWUwUnHgn9gvXXMwf3PIuLtmSpSej+kz0pCx2D2SXpMOwOBfhki1ZPnngUvq6Ugzmkgx3p+oW/eXEu5f62Hb5EJqNx2r+v373p/aTS5pxmM4QkEua/O5P7W97/RQcn76MhRsEVLwANwjoy1hMFqorSuZslfPQirUuxNA5DxrNJqKZgFTCNHD8IC4NS1pGnNewZzBHvuJSmiqFFQ1B3A0z8MC2DDIJi3zFrSsPE0I9TgJWTf6EKQSOF2AYgn3DOcquzyPPn2L/jl4euv2at/S+aif+2x54um2J3FLj3ct5bKs4tWZjslr/rwP7hvilHx1pkFU/sG+Iu792pOX1k02YjM2U4+OBhImCS8Y26ck0v3YnCg6miPvKxT1iJgoOV+3qa1pKvF5oz4NGs0mIXKF3f+0IAL/zsSt56PZryFe9uJxsvuziBRLXlxQdnyOn5jgRGg4QxVlVSCFAsLU7Sb7icnK6RG1xg+MrD4URTnSer8IgFS8gQOVOFKremjXpqS2Ry1dcRicKvDFV5Pk3Z8glrSXHu3Uug6YTh46O8+C3RylUPfzwun7w2ypM1u76aVXiWXb9luWdsNADI8pdiL53d1w/wlzZ5dh4nqNn5zk2nmeu7LZcxM01Xt218aDRbALaxe6jCS4Se/Jr/Jm1ns0oehFImCu77B3KYpkGZ2bL+LIx69w0BNt70wghCFBaERECOD1bIV9x10SJMXpPtaWphlBdPScKVSbmKw2TbLN4t85l0HTi7r97mfmqH4cBAgnzVZ+7/+7lttdPqxJPSaPHIDI4sgmjIYchALIJtVSL8ARRzpIA+jI2zRju1qWaGo2mA+2U7qJysvF8RUndhluZKJwR4YflZAbKgzCerzBXdmmWd2WKhd3R9t4UJ2fKDcaFEDA2XSJAPXb/b/990y6azejU3XKmWOXEVJEgIO6XIYGtuRRVz2fOC0LJbAlS4PoB9z7+Knd/7Qi5pIWUkoLjs7Mvw3t29fCtoxMNLmmNBuDUXKXl8XZ9ZtqlHEQGx+Lyztv/+rmmj8+HicvN5K7PtBhfLtXcqFgttPGg0WwC2sXuownujr/5LkG4Y0mYQglDLQqZSkm888kmLWZb7J58CfhBrC9hGgILNSlGieXVGqvDbtNFczFL7W7Zn7GZKLj4EoIgYKArQXfaZnSiSiAl+4a7ARXWGJspc2K6xNZckmPjSmp4e2+K45MFnjnhMJRLsKs/U5ejoQ0IDVAXrmt2fCW5FffcfEVTgyOqaFqM48uW3/Fyi5LMU7PlpsdXC208aDSbgE59GQ7sG+KqXX2cmCpwbr6K40uMoHHSqZ263pxuP/n4Er5zfArZJKRRS8I0YgXLZl00F7OU7paeL5ktewtNhCTMll0yCYuqFyCAV07Pxa5mQygp7MmCo8Yi1d/RffNlj4FsSnfLXGNWq9/EWnH/N19rSIxcC1ZicLT6jrf67mmdB41G05GlxO6vHenn3Hy1LnbbjkUSEE0JOhgOi2nWRXMx7foFRPdF/TbsUB0zUtY7F+pLeEGYrV4zTlDCOkIsdA6tFdwBlVB6dq7CMyemO4pLaZbHavabWAvu/+Zr3PfE65Rd1f211lO2EWj1HW+Fv8a1mtrzoNFsAprFXq8d6efg4VHu/toRdvZlODldjJOs1mpaaXZu1WRLeR8CqbT929HJi3J8skDJUTuuqDOnQFV8yEBSq81TPw5JygpVLkORHSCW+o0SSgGSpqgLl2yk3fGFSjuP0vn8fFt5Px588nicPwPq2vKCYHFkb8nnW21a5Vd8/C+fXdLzlVEtsVepDEN7HjSaTYYEZksOf/X0G3W7vLHZCoah+lekw5/VJtLkFyxMLhK1QFfCxLCetN12t9mpu+VEwYkNgyAsa8slTAxDkOwwMbp+gOcH+FJ1Ac2lLAIJ3WkrltUWCIa6U2tWZvp2pZ1H6XzRzvtRdHyklFQ9X3WX9fwFlcgVnG8tWY7xL6VkruRycrpMvkXjrZWgPQ8azSagNsmw6nqxOM1UwWEgm4gf5wXgNcl1WC1iT2m4g0vbRl2nwKFsgoRltN3Rt8tgP3h4lKFcgpmiSyXMbTANyDs+hhAM96R4c7pUF5IRYiG5TQhBwjLY1Zem6PjsHsjys+/r56nRaZ45MY0VejJOzZZJmFUGsgnd/GqV6ORROh+0834kTEHZrSljlp1DewcPjzJfdpiveHHzq+6UpV7HELhNTmAbomluRacqpENHx/nsIy/GehOThSqffeTFts+ZLTnMld01CWFo40GjuYBo5SKNJsV82WWisFAhIVHqdOcbE7ioN4WUkK+qiTWTMEknrJbu6uYTqlKljASwnjkxTdJURgLARL5K1VM1+Dv7UuRSNgNdCcZr3nNkOAxlEwx1K7nib3zmA3XjvRO46b8c5th4AVMQNwc7NVthz1B2TT+rtwvtOlCeL9pVJQ1kk5ycKdc1wuq05L58aoZCdaGqKJAwW/Y4cmqGrd1JxmYbyyiTluC+J14PQyRLz6249/FXmS44cTWU60sct/V3WwDTRXW/H0i+c3yKf/z+OP/m6p18dP+2jq/XCW08aDQXCO1KGKNJ8fhkcV3HmLIMHC/AsgykVItvIFWppudLTs2WOTtXxpeSsZkyh46Oq54cYbJaswl1/47e+H2nQmnt07MVLupNMTKYpeR4TOSrcb+NrWEd/HhNNcVAV4KtPWlKjtdypxv19PADGSdgivA4bPxKgY1OO4/S+aKd9+PkTImhbILJohN7EQYXGaKLiTwVi1tol1xJ0mru4Ss6AZYpGnIrHnzyeNuxHxsvNBWQakVPyuTUbJlvHDnLN46cZSo0JLwg0MaDRrOZWbxYzZacBpfrZKHCnQ+/QNULODdXXvNmOO3oSpiMDGaZLzucna9ydr6KZQiscBfv+IGSskaJTAmhNBtuGZvlvideV4u2AGGoCgo/CPjyt46RS1p0JU160ikGsklOz5WRSMbnlb6E60s+cd1uHnn+VLyrNU0Rl3QmLIN0wmyoQFn8+Z6aLSMMkDUzsjBgslBta7gtZfHzw1bnb3fWuz9IO+/HwcOjjOcrsfEJSoSpnfEQGZaLUyOklEy1UZgkzK2I+leYS6hCalNY0ZT5qs/P//kzdceuGennZ9938fJO1AJtPJwnLrnr6+s9BM0FRLPF6sRUiR29C5Kz+YrLZF4lD/ZlLCYKa9uCtx2CBVEoyzS4aldf7A2ZyFc5t0jn35fQn7RwPJ8/+v9ej2OygaRO9VJKKDk+ZccnaZl0hy7nyUKVihcwlEvFu9f9O3o5eHiUY+N58hWPLV0JgkAyUXB4Y7pM2jb4jx+4lAP7hpp+vgXHxxAqoTTCCwIcXy65UkAl3KkSUMdTP64fIBDs2qL7Zaw2y/UGdfJ+NDMs2pGyTUpNFv1WxyPcYKGMWEpwJWRsg9Iq5iNFG4nBbJIbr9zKjVcOc/m2Hvq7Eu2fuES08aDRbECaLVa2KTg3X6U7rb78E/kqCEiaBiUniHf464ESnKyvjDh4eJQTUwUmCo0NgixDMFt2O07OhljoAjqRr5JL2XSnbSxTxKWWd3/tCDsPZxjuTvDK6TnmKx6GgLLjU3YDEmEIRQKPPH8KgAefPE7J8UlaBgPZJN1pO/R2QGDIOMnS9yVlfJ45MU2q5rGgQjRvTheZLTk4XkA1NBSaYWmvw6qzUm9QK+/HgX1D3DI225B384ffPNbyXGlLUGrimEhbAsdr/31cfE9/l01pdnWTmX//p6/k6ov718TrpY0HjWYDsjixa77sIgNJ1ZccO5dna3eSiqcqDCJXvmUILFO1xD7fNoRAuV9rPQEvjc3yzInphrGYgljIqRNbuhJkEhan58pUwtK5qMlXVALam7Y5enaOp0a9+uZeoRGRtMzYuHE8nz859AO8IDS2fBlrO6Rtk4rrYxlCiUeF78lA5WFUPZ9TsyU8P0VXyqLs+AxmU3FSmub8stq6EYeOjvPI86cYzCXZFXoeImOzFQWn+UWsji/vS1hZyhdimbx/9xYMIcgkTDJJi8wqlmevmfEghPgL4CeAcSnllU3uF8B9wEeAEvBxKeXzazUejWYj0srtWpvYVStelDAAAWOzFeXGT1l0p20mC1Wqrq8EbdbB+dCXsdkadvH7tf/+PVxfUnZ8giZWzHJit1XXp+T4+IFECMHZuTJ7tnbHZXCZhMW5uTIzJa/u3JFYVfTyMhSFylc8vCAgZZmqE6chIFBhkGzSxPUDBnNJUpbB8SmVfDqQSwIwPl9FIpkuORihl+fW9+5sOm7XDzg3X+HMnPo5N1/l93/6nUt/45qOtKucaMdnHn6eR186G+eh3Lx/mC/felVLY6QdbosF3w1b07djcVVHqdre65CxDUru0g2MbNJkuCdF2jYR4sLyPPwl8MfAX7W4/yZgT/jzfuC/hr81mrcF7dyutYldteJFF/WlyaVsSo6HbQhKbkDJ8cgkjDjhyjZUTPV8YQjCEETATMlhtuzSwnu/bOarPrYpMIVgIJfANk3uuH6Eu792hN60zbm5ctOEtlr7JAgkAZKBbErpNxiCgWyC07MVpFBykxUXutM2/9f7dvHCyTnOzqvk063dSbrCxWSoG6YKVapeQH8mwUffuY10wuQfvn+Os3Pl2FA4O1dhIl9tsOG08bC6rEQ34jMPP89Xv3cmvu0HMrz9PCdnSpgCRicKseporUZKM1pd5ku5/BdfH47f3ngot/hSD3ZZTBQbjZwfu3yo7rNZbdbszFLKw0KIS9o85GPAX0mVrvq0EKJXCLFNSnmmzXM0mk1DO7frQ7dfEyd2nZgqkTSV6qGUC5ObIQSfPHApT41OMzZTJmEKDCHwI/1l1MJ+PkIYpgA3kMyUlm44LFUm2w8k3Smb+bJHxaty58MvcFFPirLrM7mEkEFU5fHmdCkuwfQCyVB3kumiQ9WTpG2TT39wDwAvnJxDosR8SlUfKQVuEIT5GaqK49VzeV48NdfxtY0wlHNRTaKrZnXopBvRTDfk0ZfOAo2llY++dJa9Q1leO5dXC79UYmqR2Nr5IOjwvWn2XUnbgrIn6UmZ5Kt+nVDV2fm1DaetZ87DduBkze2x8FiD8SCEuB24HWDXrl3nZXAazVJZ6fXZye0aJXbd9sDTjOcrcXzeQMQaBH/99Bts6UrgBRKrJt4fcb5yH6Kcgk4JkBGmWHr4QoYdM6Oyz5LjM1V06sISnV7Lq2ng5Qdwdq7CUC5BT9qm6gV8YM8gjx05wzPHp/HDHgCqXj9gtoOkb1/GZltPiuGeNNt6UuHf6vdQLqXalRvr1wlgs86f7SonWumGtFJa9ANJvuzUX5OyoWN9A60M4JX0j+lkczcLW1Q9iZQ+V1zUXReakFKuuTJqW+NBCNEtpZxvcd8uKeWbb+G1mwVhmn7eUsoHgAcArr766nWsZNdoGlnp9blUt2u0wxrPV9SXRgBS0JO2mSo65KseliHCUsnz//UIJLEq41KNB38ZDbqix6jMdUHCFGRTFrZhMB0K+jTDCJ9rGAIzUAX1gZSx7PCZmp3Z3714uuM4MgmTd+/s5d27etnWk2Y4NBLWokfIarKZ58+vfW+MZ05M4weS03MVhrsTS2pytViXwTQEE0VXJfOG90cN19pd0jv60pxs4p1odfytEDTpsxGE36Oy65932e9O5vCh6A8hxLcW3fd3b/G1x4DabKMdQOdvsEazSVhKG20Id1g3XxEuehLLEPSmLSYKVbxAUnUD/NVKMlghbgDVZSZa1E6FSy1l9AJJ0jaxDMF8xeXWq3c0fVyYBxlWZEh8qXaXUjYaLKYh2NaTajkGAezsS7N3KMfv/OSV/PRVO7j20i3sHuja8IbDZibKX4i8CVH+wmcefp5iqNlRS7tLbM/gyhbaqy/uXdbxiJWkL9YmA0eGDSjjeCnzyGrTKWxR+x7729y3Eh4FPiWEeBiVKDmn8x00bydauV0Bbnvg6YYKjKt29dWFL2p33N467ydNAywhqC5TBi9hirhVMHT2RghgruzGzYH+n2fHmj6umTci8tqYAnIpm/5Mgt/5ySsZzCUxDcFH7v92y7r8lG1wdr7zTtI0VN6JYagkT8MAQwjsdQxbbFba5S90JUyKjoeUCyqO7QoO3pguM5hN1PWi6NBQE4DHXj67rOPxuZsce8+uXr775mzL5xhCYAiprm0ZHVOG9z03X3HeZb87GQ+yxd/NbtchhHgIOAAMCCHGgN8CbAAp5Z8Cj6HKNF9HlWpYS3yLAAAgAElEQVT++yWPWqPZJCwWrFlKBUYUvogWWts06lQZ1wPbNPADySVbMpwMExOXko+wpcuOE7vMUJip3dMil3LQwUixDMGBvQN8b2wOGQQLnT2lylGwTJNf+tGRuMEWtC67k4DjBWzvzdCbSWAKgTDAFCI2FkxDaPnp80y7/IUP7Rusq6qoySEGGg2OshuQS9mYQvViiRJrjQ65Oa2M5eUY0SnL4OPXXsxnPvxD/NDd32j5uKFcY+OuQKrj6yH73cl4GBJC/Crqc4z+Jrw92O6JUsrbOtwvgU8udaAazduBpVRg3PE33yWQkqRl4AWy7Y7qfFEJQxZvTpfI2gaVcPIMAtnWK1Kbd7DU+dYyBDdcvpX37e7j9x57FSGV6zZKGAsCpf37mx99B8+MTvPwcyfJn54lUgueKrrc+I4+PnzlsPIQhF4C0xAEvmxqvEgEv/LBy1ZN2lezdFppoZiGaGpAmIbg7LxDb9pqaJU9W26e/CpQ3V939KWZLDh1pZpvTK9+xcWv/thebn7XNoZ70nVy6O3oSpiYYfVUZNyYQh1fj6ZtnYyHPwNyTf4GeHBNRqTRvE05dHSc59+cwQ8CkpbJYC5JLmU3VGBE4YtMwiJfcVVb6nUee0QgYd4JVpRtHiW4+UHQYEgYgGUJtnQl+fSH9vAjlw1gGIJ7Hz+KRGIssqAEsKs/w+6BLsbzFV4+NYdtLpSu/v2rE+x76gR33rA3fs5QNsHYXOMnaRtwz81X6A6a60A7T9zN+4f56vfONIQXbt4/zLNvzLKjL9NQgZCvzKtra9FzdvSl2REmMI8MLrRg7yQStVL2b+/hN/7nkYbFfkdPsuk1uKMnScHx6e+ymSq6cSimv0sJxL2Vpm0rpa3xIKX8z2v2yhqNJiaaJKOeCiXX58TUQqmVIeC6e78FQpBNmMyXVce+bNLCNAQ/mFjfVtyLWarh0JsyMU2D7b0Z3nNxL987OceJyQJFx6c3Y5MwDSbyVdxAsrs/w+duupwPXr41fv7IQBevTxTjyVSFPQSXDnRhmQaHjo43dOxUPUBUC+Ra4yGXTmDMVZGiJttewmVDOW04rBOdPHHQXC0yKm9eXIGwZyjLmfkK82Uv3r33pC1+52NKBPnXH3mRUzPlUL7cIJdqv79eiZEMtFzsp0vNjZXpkseu/jRn5yrYhhFf6zMlj4Rp0JNZPZnupdKpVPMK4FIp5aPh7S8DPeHdf6zlpDWa1SGaJHNJiwm3UdwlkEqSejBrk7QMJEpuea7ssqMvw6mZEpUlZk2udMJbC/JVn+29NoWqy7eOTsQ7/MgNOzZT4qqL+1u6Ye+66XI++8iLcQKlaQh6kzYfeec2bvzyP3FsohCLVklJ2LjKwGjSAjlf9djZ3+i2LlTXZvep6UwnLZQv33oVX7618XmtBKQ+/9F3AM21IQ4dHVffC4HyWIjO35OVfo9aGUQlt7myRMn1F7woUcJTOADXDxqqfpYi0/1W6RS2uBf4/ZrbHwY+D2SALwA/uUbj0mjeVkST5Nm5StvumJMFl5KjOjg6XsAV23JxnftS2SiGA6hJeqroMjKYrdstNUskbVaBcmDfEF+65V11i8G1I/381dNvNGhARH8qdU7ltallZwu39VAuFY/hfMeVNzLn4/PY2Zfh+GSBfMWLDbpcymL3QLbt89oJSB06Og40fg8OHh4lCGTcWM4PJIG9sm9L5BloxUoW+3zVoy9jMVV04zyOLV028xWfyUJ12Z/RW6VT/dA2KeU/19yel1L+DynlXwMDazgujeZtxc6+DGXXx/GDtpoHElUVYAjJfMXjqeMzyzIczhemUJNbp1xOL5AUHZ/RiQKeHzSdQKOQzni+UufmjRaBA/uGeOj2a2LX8x898TpThdbiUaA8OR/aV5/z3U53o9MY3m6cr8/j2pF+JkJPkCGU4TdRcLh2pD8ex20PPM11X3yC2x54uunr114G7cb9yuk5pkthPgFq8Z8uuW3HZ7a4wLd3J9s+r7zIw7AUUadswmQ6zHcgGl/RJZsw2n5Ga0Un46E2QRIp5TU1N9++JrdGswKCQOL6ARXXp+R45Csuc2WXmaLDbe/byWzRwfNlx9a8ASypnfV6ErC88IgXSE7NVhq8AVAf9xZC/bZNwcHDo/FjahcFN2heMVFLNmk2aP9HYlxDuRRzZZehXCoOoyxlDG8nztfn8dToNEO5BAnTIJAqVDeUS/DU6HRbQ6DVfV/8xlEKFZfjk0WOnJ7n+GSRQsXl4OHRhTBWpDK5lM/h595DLmnGAlSGgFzS5Hd/an/b57UyUjOJ5pUXmYRJ0fHrhKJAVSgVnKDlZ7SWdApbnBZCvF9K+Z3ag0KIa9BqkBpNA14gmchXCaQkkFK5PgPwpUS28WOWqn7Y0Gppr7ERMQ1Vc35urqrcvst4bjW0ho6ezXP/N1+rS2RcSuvlusUsPNbqU7IMQdUNODaeb7ivVbjkmRPTpCyDgWyS7nAs5yOuvFFZaTvslbzOlq4kA9kFPY6ob8PBw6O4vs9UYcFd3522YgOmWV7Ba+OFOk9dEHoXXjk9Fx9f4tcQgBuuGOaPbrtq2QJNrUSdPvyOoTp9iogPv2OIx46ca5DPNlDfnVaf0VrSyXj4HPAVIcRfAlFy5HuAfwf82zUcl0ZzQeIHknyluavTDyTjedW2+cxshbPz4d9zZY6dK6yLUbBayZPRzitpmRiGUo2MJmFTwJauRNPW2YuRwH1PvA7AnTfs5dDRcebLLmfnKiTDxRvgXL6ClEqJ847rR+oWs6RltPXeGEIgUbHtdtSWCSZNgeMHnJ5TNf/dafu89A/YqKykHfZqv86x8TxzJTfW6vACyWTewfXzpGyzaXvtViG++Yq34g60L43N8srpOYqOz1zZ5aWx2Y7GQytRp7PzDpZR71m0DBaE1AyBWaNW6gcBQSA5PVtmtryQC9Gbtvmh4e7lv5ll0KlU8xkhxPuBTwEfDw+/AlwjpTy3piPTaC5A/CDg+6fnY6Pg7FyFM/PKWBjPV1Y0OXWnTPIVf00SHaNzNkvSjErJpsLEw6Rl4PpB0/cQSEgImMhXMQ2BLYw4rmuZBkXHJ2l2lq+OVP0efPI4+3f08oVHX6EraVJ2VD7IyZlSbJQYhuCFkzN89pEXGehKxM2BhntSjM2UWxpjjh9gm6rBFrRO/Kv1Zgx1pzg9W0EimSxUsUxxXvoHbFQ6tcM+H69z58MvgCDW+BACAqGMwsFskmPjhVj5MwqLtWMl381W3TuBBiMgwmqTLPC9kzMNz/ECdXz3lgyvTxQRoTBc1OCtyzbqcjMib8pw99oKmnVsyS2lHEdVVsQIIXYKIX5dSvkHazYyjeYC5AcTRT710AttHyOAwVyyrnXzQ995E6eJuqFAuSUTS1h43wq2aWAIWSdzfVFPmu60TSZh8uZ0uaWSZeS9CFC780imOXq4CJO4LupJc3K6BG12eBIVD3Z9j3sffxXbFPSkUwQBTBSq8fNMAbYhkAHMllxSloFhGJQcj2zSYjCX4EwTsZ2ILV0Jdg9k24oQ1Xozcimb3rTHZNGh6PtM5Kt84rrdb9tqi07VDKtVhXFg3xC3jM3y4JPHKTo+XQkz/txtU1B2VS5RbXVD1C8FiK1jGbQPG7aiU+v4B588jh/IhhDdg08exxQCr4nJbwrR8jMqt2guV3YD7rrpcn75b56r86qlLEGAaPAgCuBbRyeW/D5XQkfjIUIIMQD8DHAbsB346loNSqO50OlOWaFhkGZbaCBEhsLW7hS2Wb/9+O/PjVH1G7MEJFD1JHartO5VwguChsqIkzMl0gWThCUwxIIEdetzSOX6DSSWYcThCz+Q2IbAMgX92QSD2SSvjRdq2og3IoBjEwX6MzanZspUvKDOeAnCXZdpCGQgmSg4HPy598SL2SVbskzknTCcIhp6f/iB2r0ePDyK49XHzXMpFTevdZnPl11myi6mIUgZgsFckkeeP8X+Hb1vawNi8XtvZ4x1+pyaLagAjzx/isFckl2h5yH63Pdu7W5SxmmzeyAbGn4mU8WF5TuTMCg5za83U6jmZ1UvwDYXkha9IMBvYz3MV5prgMxXvFD2vN74MAW4gWz5GbXjpbFZnEVjcXyJ9Bq9khLWXJ+kk0hUDvgp4GeBvSiDYURK2bwPrkbzNufi/gz/41M/QleTqoEI2zRIWAaJ8Lfa9auEw8gVuRh3jbwO0Y7Fa+L1CKRywxYdlZglwgc3m6giLEPg+BJDBuzoTVP1AmZKLpmkxVAuxec/+g4O7BuKFQDnyy4TTXIhhnJJpotVJgruQgLkohd2/QAvUOMU4SiU6qDixi//E69PFGmW1REdee3cvIp3o/pbeL5kquhQrM6wo6+LE1MlbFMZKOrzEgx1p86bit+FRjtFyHafUyujoythtjxfFNIY7rHikIbjBXz82ov5g78/ypmSp3pBoK6RVoYDQG/G5t9dewn/5VvH6soo30qvs66ESX6RcRFIFW5r9Z7a8eCTxzENQbIm58ELgpZzw1pnUHUq1RwHfhH4PZTS5K8BnbOeNJq3KUnbjA0HQwhStkl32mYwl+Si3jS7B7rY2Z9ha3eKvq4EXUlLGRKWEbduTlnGW+53v1Tkot8N94d3BHTueAnKMMomTQIEY7MVSo7PJw9cynN3/xgP3X5NvIBEmgrdaZvB7ELWviFgay7JUHcKI5wkIxnh2s8kKqWLDC3bFA06A3fddDm9GZtARgu/Ov/F/Rl60naYra/uixprGYYgCCQFJ8DxA3b0pkCqLolCSi7qTZFL6WqLVpycKa1IAKlV6efoZLHl+aLS2sFskpmSQ286waf+9WVs600zU/bwpWpVX2uMGwJ6UiYpS2AZkLENtvUk2bu1m/07ehs0VtpprnTiop5kU0NbIFf0GRUdv8GYaTe8FURplkUn4+E3gRTwX4HfEEJcurbD0WgubCxDsLU7xc7+DJcMdHFRb5qBrGpwlbLNukY9tezd2s2WroRKxFuCTsH5YjnjiARqClUfKSWXD+foSpr8yaEf8J7f+Yc6EZ9aTYWUbdGdstjWk+SKi3oY6lYlZ34gSZoqZCKhZc4FKM+J4/l1u7dIfdI2jXBhMtnZl6E7vdBsLGEZICGQEklYXivVxBgtZFEOx2L177dztUUrIrGzWpbyObUyOqLnLz7f9t408xWlkVLxAlw/YK7s8vCzJ7nl4FNMFev3uJYh2JpL0JO2w5Bh2IFVqmvnjutH+PzXjuD4MjZUBTSECZbDsYnmxoAXrEwkqithNngl17Nqu63xIKX8spTy/cDNqM/y74CLhBCfE0LsbfdcjebtiGkIupJWQ05DJ+64foSEZZJLWStK7NoIRJK+EYWqx1TBJZCSihu0VIb89uc+yP23vhvbNOuEc0xD5Ujs6s+QMI22n2kATBUdjp2brzsedSHd1Z9hZDAbazREk/WeoRwDuQRW2N7ZCuPUKdskX3E5PVvBCyS2EfYXmSkzX3bqhH00C7RT6WxHK6Nj95ZMfL4gCMhXXMquz0/+8HYee/EMv/3/vsLLY7OM5x1enyjwwslZHE8pLXYlTHb2pdkz2MVlQ1kySYvh7lTY8ayxf8XYTNh6u9Z6eAtE3wUhFn4iVvIZfeK63crYCQICGYS/W3sf7LcSc1kCbWc4IcR/EkJcDbwppfw9KeU7gfeimmM9vqYj02jeBkQiRHd/7QhdCZOpmoqCC5HasU/kqwihsssdPyCTsHA8nzsffqFOTjhKlCtWVXvxs/MVhnIpPnngUmzTxDQE23qSS5rLm+0U77h+hIn5Cq+cnuPlU3O8cnqOifkKd1w/wh3Xj2CbJsM9KX5oa47hnhRWmDQZjd8QAkMYJC0DyxScna/WqU9qFmin0tmOVkbHZz/8Q3zuwz9ET1gy3JtO8MkPXIYvJfd8/fvMheGJWgayCX7ro+8gaRmMz1cYnSxyYrJIoaLO3ZO22TOUY99wN3uGcnEIayVfuy0Zu+XxyGMl5cIPqA3GSj6jO2/Yy837hwmkSqIOpGo/3jqXem0nkk7VFjuA+4F9QoiXgH8G/jfwJSnlb67pyDSaTc7iJLGy69OhoGHDE2120rYZl23KQEnmzpfdUDNCsqtfVTL8+iMvIoGetM22nnRdHf+BfUPs39EbV1C8e1dfWAcvmyeJSVQYYhEvjc1ScPzYsAkkFByfl8ZmufOGvQ0lhx9710U88vwpKl4VyxAEAQRILupOk0tZzJXdusRMTT2tBJA6PSf6P5ycLjLck+a29+6Mm5R96WfexanZMt84cpY//NZrTC1KsjWFyltBSubLLgO5JMWqSzV0ZvheABUXifJILBaPGpspkbYNym6wrFyBTNJiqkn/i0zSIm0bjDUpF96WW9BfWM7yfujoON99c45LtmTiBNHvvjkXh9lqpw51e209D51Eoj4LIIRIAFcD/wr4D8CfCSFmpZTvWNPRaTSbmGaZ6Rcyg1kbyzQYzzvkUqq80Q1X7IFsismCmkhTlsr98APJZLgIlB0/ln5u110zEuVZjG3AQC7BJVsaOwm2ylJ/8Mnj3HnD3qaL3f4dvdz58AuUHJ+kJRjIpuKx6TyH1afs+MyXXSqujxtIPF8ZiI4X8O1jE3z95bN87+Rs3XNqZch9CYGvSoVNAb//2PdjwyGi4km8osNsSTSIR+0ZyvIz79nBl795LD5nJ5lzgPF8tUEyWoTHW4mUnZ6vrqhUs1Uli0r0peH6XpxDstosdbZKA92ocEUPqq/Fy2s1KI3m7cDi/gBnQ+njtWC1ZKhbsaM3hRCCHX0ZbntvP0+NTnNsPE++4tGXsQFJyVH16KaQnJsrM1teqMH3fBlLP+dSVsvM86jnxZ/+0yilmhi5aRiUHJ+ZYpXrvvhEnfBO0fEbVP0MAfmK17TNN6id8P23vjue5NO2qfMcVhEppSoDrqomcU+9PsV9TxzDMgTdKYszc2Xu+fr3kbI+udA2BT962SC/+KOX8KsPv8C5wsKuPzIitmUTnJpXhmptnoEMqy+s2i9DJCIlJXfesJenfjDJU8dn4ruu3d0X325HEJ9nodNmKynsQDbvu3Hw8GjL76mgdT+RjC0ouRIvCGKJ7UCqHIm1pJPOwwPAFUAe+A4qbPGHUsrOn6ZGo2lLrQjR2blyU72D1SKSyn0rBkTKNqi4CxOUIZQY1uXbehrc+HeGvw8dHefex1/ltfFC/NpVL2C8oDT8Qw0n5XIOiKWf2+3u9+/o5eItGY6ezYeJaIJASubLHpmEy5auZN1uriuhXLy1+WNR2GNx18VaMaN2Koqa5RMEkqLjUXJ8yo4fl9ACPPzsSQwRXhv5aoN4WNo26MvYGELw6tl5Tk6V41LeBoRoG3roy1hMFRf6QGzpsik6Pvd/8zW+c6J+aVt8ezHZhMlUaZEAmYTehNlSyl29n+almqkwdLKYlG207PNx5fY+rh3pb1DhrG0utxZ08jzsApLAMeAUMAbMtn2GRqNZErW6/YtLy1YbL1Rj9N9CGehAxub0vOpdYUqJG8Bs2ePkdJFDR8ebLqoH9g3xxW8cDZMO63djfhAqREYdSGWA48CJqRIJ02h6zrjV8nwF2xQIBL6UcaLkufkqScskl1Ihhnsff5WetM18xcPzfUwjMjagP2N3FDNaSfxes4AfqOTHYtWn7PoNlURSSo6cmufouXmqblB3bdqmul6Hu1MLrdoFVD2fr37vVEtj+9x8lUzCpOT4C/GH8MRCwEzJwzaNWNJ6puSxZyjFn/7TaCg4tkCn5OV2ctJ9aYupUqPKowFxH5aFxy+Uap6cKTdomgxkk237fBzYN7TmxkKz99ESKeWNqOqKL4WHfg14VgjxD0KI/7zWg9NoNjO1melrXWERzdkD2ebZ4Z0wBOzckmVrdxJTCNxATbKWAZNFp0GgqZbRySKGIFbSrPcYq0Cx4wVxQ6AdvSkcP2h6ziju60up5K+pb1EeSDg9WyFfcfH8gGMTBRKWwVBWJal5AbFr/KLedN25tejT6uAHkvmKy5m5Mm9Ol5jIV+MqioiZksNXnj3Jx//vZ/n0V75HJTQcBMqbtbM3zdZcMix9NkEoQzNhGuSSNqdnyy3DAl4g+eXrR+JrLRI3MwT0p8MFW9b8oIyYKAy26K62LC4vrT2eTtqkF23P0xb0ZxMtSzUlMJRNKMMGZexE1+5KK1nWiqU0xpLAESHELDAX/vwE8D7gt9Z2eBrN5iba2V76m4+1nAybsZQcBiN8YOSevWywi8mC8hwEy/BAmAZ0JSxOzpTY0pVkvuyRDBUx494VpmgqQXz/N19bcEE36d2hFvOFsQxmE3Sn1WTZzBMQxX0TpoEXqDhv3XsO6+kn8lV8KbENg0zCIpOw2NqTpuR4DOWUCNVyW0qvZsOnzYbrB5SqPkXHo9JiQfUDyXNvTPP4y2f53z+Yqrvet/emyVdccimLTMKk4gb4AezqUzoP2eSCwFqUtBrrMjQh2oUvduX/7XfHyKZsJgtOXG0xnE1SdPwV5QW1erxEhTROewvfVdXkDi7uSnDXTZc3DYftPJzh+GQhrlZKmKpHTHRdbiRPWKechztRFRY/ArioMs2ngL9AJ0xqNKuGbSg3/lJZyiQXhA80DehL29x10+UqAdAymMw7sX92S1ciXGxbnUnwiet289ToNOP5Sl3nTClVGWazXXuryoj6M6v3LVDjLDoLC0+zc0Zx38FcktOzCy3OownaCBtwqM6DQslL1xCd83c+duWyWkq/lYZPm5Wq58cGg9OiwRnA2bkK3zhylm+8cpbx/ELpYjZp8aHLh/joO7dx2VCWZ0anefjZk5ydL7OtJ80nrttNJmHyW//r+2onv+j/9OyJqaYtryMtsTtv2Nvgyo+u4agEFIgNyjNz5abnWymFqldXPhl5MwpVr6URcO1IP8+cmMYQC4qtEwWHn31f/+oNbJXo5Hm4BHgE+IyU8szaD0ejeXuSsEwq3tp0wfMDtSh/8RtH4xbXSctkIl+l4vmUHB9DCISQcaZ2LQK474nXSZoGlqFEn4JAyfgGSAayqaa79gefPA5SttzRJUyBIVQIImEauH5Q1/2y2TmjuK9tKuGoN6fLyPBcqpTSp+oFdCUstvemG7ppRuds1+q5GStt+HShU+tt2dGb5t//yCW855J+yo6P28badbyAf/7BJF9/+SzPvzFT9///4Z09fOSd2/jRywZI1iQOvm+knx/ZM0BvxiabtGJPgxCi6S79ssEsr50rxItyJAp52WBjuW5Eu7yB505Ms1zfQ5RH1Oz4RJgUHMiFMk5DwETBaenFemp0mp6UxWzZxQ09hr1pm6dGp+Mk5I1CJ52HXz1fA9Fo3s7Ypoi7Ny7uobAauL7ktfFCvBPPpWxyKRspJXNll6oX4Aeyae5FJM/sBgEVT9KfsZkpe9gmXJRLqX4cTXbthaoXJ6AtNiBSlhHHoxOmwWAuydhMGcsUcRlfs3MuroDYN5xjolClJ+xXET3vnpuvAGi5UBw6Oh63eu7zA87NV7nviWM89vIZ7rrp8gaDoFWZ3GbOkTh0dJzPf+0IliHoSpicnivz2//r+3z6g3t430jznfDxySKPHznDP7xyrq5d9ZauBB++Yis3XbmN7X3phuclbZPetN20G22rXfpdN13OZx95kULVww8kpiHIJi3uuunylu+pXQVN0K5EowUZ2yC/WFAiPO74UjW7q5FV94OAoE1L7qi8uTahM1/xODaeX/bY1poLW5VGo9kk7N3azfHJAvmKh+c0jxm/FfxAkrQNzsxV6uK93WmLS7ZkkVIyNltp+lyBKj9Lmkq3zvElf/4LV8cT8FAu1TT+L6LZr4naztbuJKfC1xvOqsS4vozNlq4Ec2W3bVnk4sUk2sU1K6dstVDc9sDTcTb/mbkFGe3RySJ3/M13yaUs9gzlFmLRLcrkNqNglOcHqnTxCSWYZJsGUipxLyl9Hn72ZJ3xUHI8Dv3LBI+9fIbvn1lY5AwB14xs4aYrh7lmZEsc6qolk7Dozaimccslany23FLaVsbISnpgXbm9l5fGZijWtPvuShhcub2X2ZLDsfECQsrYEAhCY7mVF8vxVAzPiL0uEAjZNiy0XmjjQaPZAETu1FyqPu6/muSSJhMFF0kQx1PH8w63vbefmWK1QeK2lmhTZgg1vqUkbkW7smYbuqLjs2dIGS1Fx2col+LzH31H09LMg4dHOTaex/ECbFOwd2t37JE4eHiUl0/NUHZl7EV5aWy2Tquh2TgjT8LxyWLcv8ILJG4gsU2YLzm8cHKG//DfniVlmZiG6pvRl7EZyCY75khcaDheQLHqUXJ9qmHC46nZMt2p+iUiZRucnS8jpeTVM3kee/kMT/zLOJWaksWLelN85Mpt/PgVWxnIJpu+XjZp0ZOxSVqro4LYbN2//5uvNdU+aHV8JVw70s/To1N1SZElJ+DakX727+jl0195gflQDE0A3WkLyxAtdR5sU1B2lSZGZHCACsttNLTxoNGsI7UTWdI0WpZ+wVtTiZTAXNnDNtTOp+IFSCmRUuUm2KZgZ3+aN6YbM9gXxJ1UfwjTEC11HWq5cnsvR8/OMVvy6sYdbUA/d+O+tueIkhRd32eu5IKAsgvHJwt89pEXEags/0J1YeEqOl6cpHnnDXtbxpYjT0Jt8qcX5nEgJU4AFiqME5XwmUKJWHl+wJ7QgNkM+Q6eHzQNv2zrTjNVrNYtdMWqyo/5xf/2HCemFp6TsAyu3zPAR965jf07euKdcy1CCHIpq6Yt9tJo9T88dHScX3noeYph35LTs2WOnJrlj267ipfGZrnvidcxhConLrs+9z3xOk/9YJJn3phtOL5SHnv5jPIORCWfqOv7sZfPsH9Hb50RIIQyCobCHi6tvFjfPTFFtSZ+mDBgz9buFY9xrdDGg0azTkTVCNFE5gZBW+NAotrsus0SEzoQ7ZyHsgkySYvTsxWEocyRkuNjGio2m7QMql7Q1FCJXrY7ZTuIzeQAACAASURBVC6p0iDyphQqXl3DL0MIZksu9z7+atvnR0mKUwUPw1DJlUEgyVc8/LB4P0qIDIsslDywoQyi/Tt6W8aWo7HVJn+qz1cJaqkqkPpPIJAqtDGQTb4tGmPd+t6d3PfEMdUOG5gpug3G7aWDXXzkndu44fIhcqnmGiKGUMmsPWm7aeiiHe2qXO7+6kt1+QaBhHzV5+6vvsR81Q+/V0Y4BtXv4anjM9imaDj+4JPHlzWuiB9MFheEpcKLKJDq+L2Pv0rZDbCNhfyFshuQLzsYYfv5xbk4B//pdZxF7j8nAOTGC1ss3fxbAUKIG4UQ/yKEeF0IcVeT+z8uhJgQQnwv/PnEWo5Ho9lIPPjk8XiCM4QRT2itEKjdsSHqVfA6YRqClGWSMAXzFa+u1TRSkLQM+rtsZkqu0mwwiF+gdq43QsGaHX1dsa5DOyJRmygB1BBRvFeJRR2fap9seHKmFNe7RxtZEYZb/FDjoW59DyfoKLRSWyEhhPpdq0dxz81XsHugC1+CMCBpilja2AoFqBazlHFvFi4ZyHDFRd2cy1c5PVuJDYeuhMn/8a5t/OnPXcUDP/8efurd25saDqYh6O9KsKs/Q39XYtmGA9D2f1jbvyL6ATg1X6Xo1MuRw8K13Oz4SkOFXpQoEZ1TLBw/PlVSJZeGCJtXKZXViaLbUuzpmTeaCzi3Or6erJnnQQhhAn8C/BhK1vpZIcSjUsrvL3roV6SUn1qrcWg0G5VmDZvakbQMfCm5qCfNqdlyy659UC9M845tyuU5X3YYmy3jhiqLUavpgWyKXMqKuxgWHY+MbTKYS5JL2Xz/zBwpy6yrjV9qpcGBfUMkTAMpJWYH42gxUWghEoSKdm8J0wg9D4JA1hgQkWtYqgWuU4VElA8R51Wcmydf9UksCsPHn+XGCzuvOq4f8NToFI+9fJZnj0/XGVDv3N7DR945zAf2DrZNcLRNg56MTa6m3HKltPsftiqOkBK6ko39TGpbsi8+3pUwyVe9ZbXjBuLOnIstTauDodQyaTMc5OKGXssRkDtfrGXY4n3A61LKUQAhxMPAx4DFxoNmg3HJXV9f8mNP3PvRNRzJ5qZZw6Z2RHoIlinozdhMF514Imw1t9QmWlmmwZ7BLKfnKk1bTUfVBYs7SVqGQW5R4txyKg1GBrqaZp3vGewCWse0o7F0py0m8w6BUG8yl7Lj/ATXD1R3zhrvRiDhQ/sG+dbRCc7MlUlZC4ZQs3HXTuRRI69jE4XYaIg+2ujc0bg3E29OlXjsyBn+8fvnmCktdKrsy9j8+Du28pF3bmNnf/v/d8Iy6M0kFvpQLJNm10G7KpepotO0f0UmTIK874nXGzpNXru7j2femG3agfJvn32Tsblq07G14rJBdW1H9oNA5cZcOtiFEKLtdd+MdroRG421DFtsB07W3B4Ljy3m/xRCvCSEeEQIsbPZiYQQtwshnhNCPDcxMbEWY9VoVsxKr89PXLebQBK63wO8IGgZjsgmlBx02jYYyqX40i3v4j99aI9qUmUIFWqoQTWNUjr6tfr5d910Offf+m4u6k0z3KM8DrXa+s308z954FISltlUi38pfO7GffRlbBV28dV77MvYfO7GfQuNrhZ1t4wSMu+5+Qou2ZKlJ6N0HHpSFrsHsnzplnfxB7e8i8u39ZBLGpihS7grYXHz/mG+++YcmYSJIQSOH3BqpsxkodJx3Af2DfGNz3yAP/+F97JvOBcr/Rmo8FI07guJdtfnd0an+LcPPM3H//JZ/va5MWZKLoaA9+/u5z/ffAVfuf0a7vjApW0Nh3TCZLgnxY6+zFsyHJpdB9eO9LfsA9Gqf8UvXz/CnTfs5dMfvIy0beIFylvx6Q9exkN3/Kumx++8YS+/+1P7ySXNuvBGLmmyJdP8Pe3oSXLXTZfT15Ugaavyy6Rt0BfKT7e77ltx8/5hiN6PXKi2iI5vJMTiLmerdmIhfgb4sJTyE+HtnwfeJ6X8lZrHbAEKUsqqEOKXgX8jpfxgu/NeffXV8rnnnluTMa8ly9nNX0hsMM/Dupvny70+F1db9HfZzJVdSq4SkzEMQcZWdePNsvvrnm8Z9KcthGGwoy/DtSP9PDU63bQGvp02QjOW+/ilPv+2B55u2FlGcsErTUqsPed82WWyoFo8ZxIm99/67lUZ9wrZcNfnUz+Y4rY/exqA4e4UN71zmBuvGGYw17zEspaupKqcWIlGw2LaXQd3XD/S8n+wmmWX0Pz/ffDwKN8ZnaorYzaA949s4aHbr2l7jazk+vnMw8/z6EtnY+Grm/cP8+Vbr1rxe1oGy7o+19J4uBb4bSnlh8PbvwEgpfz9Fo83gWkpZU+782rjYWOhjYd6Vnp91maVL1ZK3AzlgK247otP0Ju262LjkV7Dtz/Xdh9xXs+5Smy461NKyW89+gr7t/fww7t6m5ZY1iKE6nLZm06QWE7CTgc28P+Mq3/3H5kruWHiYxh+CCQ9GZvn7v6xdR3bKrOs63MtwxbPAnuEELuFEAngVuDR2gcIIbbV3LwZeHUNx6PRbFjaZZVvZnb2ZRrK/96qcuNanHOzIoTgCz/xDq66uK+t4WAIQU/aZmdfmqFcalUNB9jY/7Na1UeBKhlGsCFVH88na2Y8SCk94FPA36OMgr+VUr4ihLhHCHFz+LA7hRCvCCH+f/bePD6u87zv/b5nmQWYwUYChLhIJCPKdCRLMi2pSq0qtK302nUjpYnaSOmS9mNV7Oe2kZvWbpw29W3ltLVveuNIvW1KVe2t3SSWE7q2+amXJLJM00ola6ElWbIQkQJJcccOzD5nee8fZ85gBpgzwIAYrM/3I4iYM+eceWfwnnee8yy/51XgEeDvtms8grCWCcsSa9novRMg0FuIimmvpXNuVizDYEtnnGv7OtiSimO1IO7UCmv5b2ZXko59P1Ax9SsJjWtR9XElaatIlNb6m8A352z7dM3vvw78ejvHIAjrgc3UO6GWZo2K1tI5Nxsxy6A7Wd/dsp2s5b9Zbd+ZsCdMOmGzZ2t0987NgChMCsIaoFmr4I3OYvpkrIVzbgYStklPh11nxK4Ua/VvFl6bg93Wprs2myHGgyCsAdbynZew8bma7pYbHbk2GyPGgyCsEdbqnZewsbFMg8HuxGoPY00j1+Z82trbQhAEQRCEjYcYD4IgCIIgtIQYD4IgCIIgtITkPAjCGiGqQZQgCGuXzXrdiudBENYAzRpECYKwNtnM160YD4KwBtis8tSCsJ7ZzNetGA+CsAbYrPLUgrCe2czXrRgPgrAGWMuNgQRBaMxmvm7FeBCENcBiGwMdGxrhwSee567PPcODTzy/KWKrgrDaRF13a7mhV7sR40EQ1gAH9w/w6L03MpBOMF1wGEgnePTeG+uytjdzcpYgrBbNrrvFXLcbFSnVFIQ1wkISuLXJWRD0I8iXXQ4fH94Ui5UgrAYLXXebVbpaPA+CsE7YzMlZgrBayHXXGDEeBGGdsJmTswRhtZDrrjFiPAjCOmEzJ2cJwmoh111jxHgQhHXCZk7OEoTVQq67xkjCpCCsIzZrcpYgrCZy3c1HPA+CIAiCILSEGA+CIAiCILSEhC2Eq2L3p76xqP3OfPajbR6JIAiCsFKI50EQBEEQhJYQ40EQBEEQhJYQ40EQBEEQhJYQ40EQBEEQhJYQ40EQBEEQhJYQ40EQBEEQhJYQ40EQBEEQhJZoq/GglPqwUurPlVKnlFKfavB8XCn15crzP1BK7W7neARBEARBuHraJhKllDKB/wj8DHAeeFEpdVRr/eOa3T4GTGqtr1dKPQB8DvjFdo1JEISV5djQCIePD3NuMs+u3g4O3b1XegQI6w6Zx/Npp+fhDuCU1npYa10GngLum7PPfcAXKr8fAT6klFJtHJMgCCvEsaERPn30DUYyRXqSNiOZIp8++gbHhkZWe2iCsGhkHjemncbDDuBczePzlW0N99Fau8A0sKWNYxIEYYU4fHwY21R0xCyUCv61TcXh48OrPTRBWDQyjxvTTuOhkQdBL2EflFIPK6VeUkq9NDo6uiyDE4TlQuZnY85N5knaZt22pG1yfjK/SiPanMj8vDpkHjemncbDeWBXzeOdwMWofZRSFtANTMw9kdb6Ca31bVrr2/r7+9s0XEFYGjI/G7Ort4OC49VtKzgeO3s7VmlEmxOZn1eHzOPGtNN4eBHYp5Tao5SKAQ8AR+fscxT45crv9wPPaK3neR4EQVh/HLp7L46nyZddtA7+dTzNobv3rvbQBGHRyDxuTNuMh0oOwz8C/hh4E/hDrfUbSqlHlVL3Vnb7r8AWpdQp4J8A88o5BUFYnxzcP8Cj997IQDrBdMFhIJ3g0Xtv3PRZ6sL6QuZxY9pWqgmgtf4m8M052z5d83sR+OvtHIMgCKvHwf0Dm36RFdY/Mo/nIwqTgiAIgiC0RFs9D5uB3Z/6xmoPQRAEQRBWFPE8CIIgCILQEuJ5aIB4EwRBEAQhmk1lPIhRsHq08tmf+exH2zgSQRAE4WpR601WQSk1Cpxd4uFbgbFlHM56Y6O//zGt9YdXcwBXOT/nsl7/XjLuxqyV+Zljff59lpv1Ok/bwVZgqJX5ue6Mh6tBKfWS1vq21R7HarHZ3/96Y73+vWTca5vN8j4XQj6HWZbyWUjCpCAIgiAILSHGgyAIgiAILbHZjIcnVnsAq8xmf//rjfX695Jxr202y/tcCPkcZmn5s9hUOQ+CIAiCIFw9m83zIAiCIAjCVSLGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILSHGgyAIgiAILbHujIcPf/jDGpAf+Wn0s+rI/JSfJj+rjsxP+Wny0xLrzngYGxtb7SEIQiQyP4W1jMxPYblYd8aDIAiCIAirixgPgiAIgiC0hBgPgiAIgiC0hBgPgiAIgiC0hBgPgiAIgiC0hLXaA9jMHBsa4fDxYc5N5tnV28Ghu/dycP/Aovf/qb19PDc8sejjl/q6UcemYiZKKTIlt+XzCGuL3Z/6xqL3PfPZj7ZxJMJ6IWoduZr1Za2y1Pe0lONW6pirRTwPq8SxoRE+ffQNRjJFepI2I5kinz76BseGRha1/5nxLI89c4rTY9lFHb/U14061lRwajTHyZEspqKl8wiCsL6JWkcef/qtJa8va5WlrplLOW6ljlkOxHhYJQ4fH8Y2FR0xC6WCf21Tcfj48KL2nym4GAoyRXdRxy/1daOOHcuWMZXCNBRj2XJL5xEEYX0TtY48+ezpJa8va5WlrplLOW6ljlkOJGyxghwbGuFz3x5ieCxHyfWJm4rB7iRdSRuApG1yfjJft3/oihrNlBjsipMpOoxmSuTKHgrwtV/df+7xjV7/xDuT+FoTMw22puJ0Je0Fjws5N5mnpzLWsudjKgUq+H0xry8Iwsagdi0ISdomubLHtbY5b3u71oVm7vrlcuWfm8wzky8xU5pda7viBmXXb3JU9GfU7LNYqWOWA/E8rBDHhkb45JFXOTmSRWuNAkqeDiZmwQGg4Hjs7O2o7l/rilIKzk8WOD9ZwPU1hgr0RH1fNzy+0et/+ugbKEABrqe5OF1gpuA0Pa6WXb0dFBwPgJhpoDVoHfy+0OsLgrBxqF0LQgqOR2fMbLi9HetCM3f9crryCyWnznAAmCn55EtO0+OiPqNmn8VKHbMciPGwQhw+Pkym6GIaCtMwsCtfuFrDWLZEvuzieJpDd++t7l/ritqWTuBpcP3A8DCUAkCpxsc3en3bVAx2JwAV/seVTLHpcbUcunsvjqfJl122pmJ4WuP5mq2p2IKvLwjCxqF2LdBaV6//h+7a03B7O9aFZu765XTlTxbclraHRH1GzT6LlTpmOZCwxQpxbjKP6/sowKncsSsC70HR9RlIJ+rcarWuqJmCw1i2VD1X2fNJ2iZ9MZNsyW14PDQOe3QlY2zvgdFMiZLro7Ti0XtvXJQ77+D+AR4luGjPT+a5vr8TpRTZktvw9QVB2JjMXQt21oQFbt7Z03D7ctPMXa8BU8HwaJay51fCtLEFXfmNQh1+RMuoqO0hzT6j1T5mORDjYYXY1dvBlekCToMw2b7+Tr708J3z9h/JFKvhBQNVfc40VDVfIV0OvrjnHh+67WxT0ZO0GcuWuDBVRClFOmGTTtjkK8e2MskO7h8QA0EQhMi1YKXWiHCN7IjNfo2F7vrJXIlTo7kgqVspXE9zYarI9f2dkeebu2aGoY4oDBX5VJWlfBYrdczVIsbDCnHo7r28dHaCuZ1PFaDU/Fl46O691Zidquxo1czWsWwJy1R17qnQaj45kmE8W66+UniY1nBhMs/2niRXZkqUPZ+LUwXe95k/oT8VX5Jmw0as6RYEYe1z6O69fOLIq1yYKuD5GtNQpOIW//KjP8nnvj2E72s8pQMvrwKlG6+1IbWhDoCOmEW+7GIbCqeBm6Gvw563bS4rtT6KzsMG5uD+AZJzspCD3AUYrQlJ1O7/6L03ojX4WmMZip29SXb2JrENVQ1VhCGH0Go+M55losZwgMC95uvgtRwf3pko4GsNlRyKqYLDW1eyLWs2rFZ9sSAIAgRrKBp0ZT0LTYORTBFlMHuvpkEZMJopRp7r3GR+3hqdtM2GhgPAZL55wuRKrY8bXudBKdWjlDqilBpSSr2plPoppVSfUupPlVInK//2rtR4VgvbVCRtk6RtkrBNDENFlvwc3D/AgWt7uW5LJ3v7U9VwwzU9Se7Y3ceXHr6zal2GVvNMwUVHGNc+wcUVt4OETdsysAwD3w+usVY1G1arvlgQBOHw8WG6kjb7tqV59zXd7NuWpitpc/j4MI6nMZQiUbvWKkXZi05UiKpaiKLJqarjW4n1cTPoPDwGfFtrfb9SKgZ0AP8c+I7W+rNKqU8BnwJ+bQXHtKLYpqLggOP5eL5GU0matKJnYRi+GM0Umcw7lCqGRqnscmxoZF6CZdnz0RGn0xXvg+drPAI3H8wa50pByfUZHs1Scj3OTxaq1msjl9hq1RcLgiA0W39ilkGh7OFrjVLB2oeGmGVEuvjDtTZfdknaQcmps5CFsMTxNaPVEMSG1nlQSnUBdwP/FUBrXdZaTwH3AV+o7PYF4OdWYjyrxQ3bukjFzarhYKjgC7vs6UgX08H9A9x/YAfjuXLVcLAMuJwp84kjr1aPC63mmGkQFdZLWAYx08A0VFWnAahqP3h+UHoZ6EgolIJPHHmVTx55taFLbLXqiwVBEJqtP/sG0mxNx7AMhecHYd+t6Rj9qXikiz8MFQ+kE0wXnGpYuB3ji2IpIYiNrvOwFxgF/j+l1A+VUk8qpTqBbVrrSwCVfzd0pt2hu/eSL/tYpiJhGdhG8EXe22E3dTE9NzyBqRRxyyBpm9imiVkpkQyPC2t9u5IWqoGxbCro7bRJJyxScYuupIXva1zfxzAC4yFw9RHEEIFt6QTZkkum6DZ0ia1WfbEgCEKz9efQ3XuxTZPB7gTv2pZmsDuBbZporZu6+A/uH+BLD9/J93/tg3Vh4eUeXxRLCUGs1jq8UsaDBRwAfldr/V4gRxCiWBRKqYeVUi8ppV4aHR1t1xjbzsH9A6TiJjHToOz5OL6Pr4P+FCevzHBsaIQHn3ieuz73DA8+8XzV2qxqRNR4FFQl/BC6pkKrefeWFH2pGEnbwDYUlgEdMZPezhi7t6T423dex9bOGBO5INnHNg16kzY3bEthGQrDUFimYntFNturGBi1hC6xKEt9s1VbbJT5KWxMNur8DL2yo5kSb17OMJopcf+BHdWyxUZrU7bsNUyKbIeLfynrY1TSZrPxrdY6vFI5D+eB81rrH1QeHyEwHq4opa7RWl9SSl0DNPTNaK2fAJ4AuO2225YehFoD3LCti9NjgXCJgaqELXxKrscnj7xKV9Kuc1c9SuCWGsuUqiVHEMTwTEPVuaYWqvWtrWPeN5CqxvTCifbgE8/Pq5s2DcXcDMxal5joPmys+SlsPDbq/Dw2NMKRExfoT8e5tpKjcOTEBW7e2VNdl+auTbuOR2tDRBGK+TXavhCtro/NtCuW83WWgxXxPGitLwPnlFLvqmz6EPBj4Cjwy5Vtvwx8fSXGs5ocuntvtcRHGVSSJhWGUk3DA+mEVclJ8IMfrUnFrZZcUwu5xBq5v1Jxi3TCktCEIAhripVy8ZsRVkLU9qthPYWCV1Ln4VeA31dKvQbcCvxb4LPAzyilTgI/U3m8oTm4f4B0wsKuSeTZ3pNAQ9PwwG/dfwv7BlIopVBKcX1/J//+/ltasjbfujLD5ekiQ5dnGB7NMlNw6lxijdyAf+fO6/it+2/Z9KEJQRDWFivl4tcRGehR26+G9RQKXrFSTa31K8BtDZ760EqNYa2wbyDdIDxQbGt44NjQCNlSULoUyrVenC6wxY2xZ2uquk+UG3Cu/LUgCMJqslIu/rBio9H2drBeQsGiMLkKrEZ44PDxYfo6bRQqCJVU/vKTeSeyk6eIPgmCsFZZKRe/jlCYjNq+WZDeFqtAoy5o//KjPwmVbSdHMuRLHmXP49DvvcxAOk5nzCRb9qqiIQCf/dabnB4PXHR7t3ayfzDFd4ZGyZU9OmMmD921p9rh7oUzE8TNoCw0W3Ipez62oeiIW3VCU0vpRCcIgnC1RIkjRW1fqJtkq+eLIkpjMlp7cuV5/Om3ePLZ03Vr/yP33NDW1xTjYZVo5pr6xJFXg2oMpXA9n3OTBUwFO3uTjGSKwfOOR97xq02vhi5nePNyBkOFSpYev/Odk6RiJv1dCRJWUB46mXfY3pOo66oZkoqZLXeiEwRBuFqiOlref36KIycuzNv+KERWVFzN+RqhIiR7o7avNI8//RaPPXMKQwUCggXH47FnTgG01YAQ42GFaGbt1j43U3AolF1MZWAYCtf3UASNrcayZbam4oxly9XzKoJyynAa+xq0VliGwvE8MiUPb7pIwfEqpZ6as+N5DAMsw+C+W7ZXX//tsRyur8Goiect0IlOEAThaonqaPnks6fpiJmMZ92qNzSdsDh8fLipF6HZ+frT8Xnbm50vSqH6KpSrl5Unnz1dMRyCWLShguT7J589LcbDeifKCn608nztc5emC3g+2IaPgVmVkNZA0fU5NyeEEFRp1M9ix/MJ01nC52OWQdkNRKkAEpZJOmHxxefPojhLV0Ub3TKoJgfFLYPBrjjZkrv8H4ogCEKFqP4MmaJLwfEwmPWGjufKuN5M03U16ny5sse1ERUaUeeLshHWiO1AruxhzcleNFSwvZ2I8bACRFnBYSJi7XMJK5jgrg+WSbWpiyJoO7tYT1lt2acxx3NgKNjbH1RYnBzJgIbB7iQx08D1NKYVeB729qfmhTYEQRCWm6jKCaPiAQ3/VQp8X1P2dNN1Nep8nbGgiqxRhUbU+dY64XuqLf7wdbC9nYjx0EZCF1iYrDjQFeQawKy1q6HOQu5PxylO5PE0eL4fhCwIBEkqjeEWRENd0yvfDzrLhV4HX8PQ5ZlAJtsN8iauTBfqLNUS8OalGUxDcfOOLh584vlFJRi1mowkCMLmoVlHy08ceZULUwU8P+j4m4pbdMZMciWXou+FinoYBN0xm3WT/Mx9NzXskPnQXXs4cuLCvO2H7t7Lb3z99YbnW+p7Wu7PCBonRj501x4+//RJXM+rdmoGeOgDe5Y8hsUgpZptorY7WsIycHzNxakimWKgLhlau3M7oqUTNgNdcTpsE6UUlmmwqzfJvoEUtmlUYltqwRpj01Ds7EmwrSuOZSo8rauTSkHVBehr8HwYqcmjmEXTGTM5+tplTo9lF+zytpSOcIIgbA4WWh8UBE35dNCZTwHd4Zd5pVlfePfUn4o37SYZJbb0yD03RIowRZ3vat7Tcn5GYWJkwfHqEiNPj2XpStb7AbqSFjfv7FnSGBaLeB7aRK0LbGsqzsXpAhrNyEwR01B19chzLWTbNPlPf/PmedbrsaERPnHkVabyTkPRkpC4ZXD4b72veu7BboukbfLWlQxlL7DqQ0vCVLOJP3M13H0NpYpnIlN06U8n5iUYRb1nmJ+MJAjC5mWh8G1X0mawO1ndP192uThVQClFzFDVEK6nNVoH62cj70K4rkZVYkRtjzqfpcBtsNzGzeVf85qd742L0w0TI4++dpndWzq4tm+2Km4l1l0xHtpErUstTEYcy5Youj4D6USdKyqsVT45kqHs+vNaxIYc3D/Av7//Fj77rTcZupJt+LoKSMfN6nH3n5+qurlCg8P1Na6vsY2g/PPsRAGoNxzCCo+gZDT4NyRKAvatKzMUHb9GIyJOOmGJToQgCE3DDHPDt+FzZU+zsyfBWLZcXVcGU3FyZW9BnYcomulG1K6XYVjgD18+z/nJwrzzDHQlm76nZq8Vtb3Z+XJlD4Wm5HrVJomGCjzHK9UptBYxHtrE3ISdrqSNZSoG0ol5Us/hZP/00TfoTiqSthlZfxz+fuj3Xqbk1vfCsBRYlsG+bV1Avdx0vFBmNOvU7e/4gUETUut50AQTM2wfHjNnI1yNJGAXI38tCMLmZSE56agER8s0qgneQF0Sd6tSzgtVvjWS5y+UnIbn0r7Pri2pyPe0FK2JZp/RWLZEwZm9xdM6uMEzFJFJoO1Ech7aRKvSqa1IQ4dS02HeQ5jL4GnqOm3WnnM8V38BhMfkyj6p2GxZZy1bO2N0JS18DemE1fR9LEb+WhCEzUuzNTHquYfu2rOsEtTN1tmo5yYLQcWFIrjbD9fOiYLb9D1Fne/JZ09HjqHZ+bam4rPjYHYcfR32qnTiFM9Dm4hyqb12fopHnvrhPAnpE+9M4vk+ccukPx0nnbAjXU/nJvNs6YwTt0wuTxerHgjLUPydO6/js996s+qZiFsGCVPRKEUi9DTs3ppiZKbIWK5c3c9Qdh/OogAAIABJREFUMF0MLppr0jHSyRjTBSfSNXhuMk+sktAZjidmKtIJS/IdBEFYMMwQ9Vwosd+KBHXUc80k+DU0fC5cE2sTNiFY56JCHQf3D0RWbzTTmmj2Gemvw0AqVl2nDQX9nTHitsn9B3Y0HEM7EeOhjcx1qTWSEf2d75ykM2ZW4lcKt1KVsb2nUjHRwPUUurbSCbta+pkvu8RMgy8+f5apvFOt+S25Po00nsxKApKvg3Fs606yrZKsNJYtMpFz2NmbrCYO5coen7nvpsgJmY5bnBzJYhqKuG0EiU2+pr9iLQuCIDQLM7Sa4NiK+F74HFpzYboUKcHfSJ4/CqV1007ES9GaaPZ+w/Ntm5NUGjONyDFIwuQG4clnTwMazw+yd8Mv71yl4dX5qQK+56OBs+N50nGTmGlw22/+aTWR8oZtXfzU3r6Gtcq2ocmWXEylMAxFDF2X6FiL62sMBffdcg0vvzNNvuziej5XZoKkTtsA19NkPJexbImS6/PIUz/k8Qfe23BC6lopzJp/9RrRfxcEYWNx+PgwZddrKF0NNKxauJSphG9r/f5zJfjnPBeFp4MxOF79GLqSVjUE8fEv/5CZQq6qv9CVtHjorj38j+fPcmGygOv7WEYw7rA5YhRR1SC2oVelyk1yHlaQbMnF8ysCTmpWyMlv8EWrgWzZ48pMkem8Q8HxmCm6nB7LcuTEBe4/sGNerXK2UlERXgfmAloQqZjJfbfu5NF7byRmGpyfKlZFWJRSnJ8qcG4yH6hOGpAru5E1zNmyx46eRFVTwjIVO3oSbZdIFQRhc/LWlZmKVLWuk64+eWWGc5P5hhUIJc8P1ilD4fkaywjWqWzJJVNyGz4XhSZQ6B3LlHErwlaurxnLlDk5kuG181PMFOrdvjOFYA3XAKpitKjFif9FaVdky55UW2x0VK3WNNSVN4xlS9hG0AzL1xrH8zENxVTBqYhDKXxfkym6DHZbPDc8Ma9qY9fxICNX+6Aa2A2q8j8dxsu6Ehw+PsyXHr6Tw8eH2b2lg46YxfBoFtfX+BWvRTAmSFhGNbFnrkUbutSisqIFQRCWE6ciUNNIunpfk5BBs+qNRmtYM8quH9xwqZoxKE3ZDRpTWaaq6jJAvS7DNXPCD4vxFDQKaew63ryKpV2I8bCCJG1FttS4P0Wh7KEVaG82q9dQ4GjqSjJLHgyP5nh7NMeHP/89PvWRd8+Wb1YkXqfyDrrizphbfhk+2NoZq2sIc+KdyWqZpef7ODXRDr/SU6M/HSdpm5wcyfDhz3+P0+OBZbt3aycfuWkwUvZVWF52f+obi973zGc/2saRCMLqEbOMSOnqKBd/M3lqmC/YFxooUdimIlfWFJ1ZaWjDCJLFJwtuw4ZVjqebegpalbuOkvZeKAxytUjYYgV5z45eepJWNZnRUNCTtNjZk6j2o6i22NZQaiRrRvU64dRojk8cebUaRghFpK7v70QphVKK/YNp/tqt11RDGIYKMna3dSerlvinj75RbbxVdAPDwZwTAtzeE/TlGM+VmC44nBrNVRp1aU6OZPkfz59tGEqRSgtBENpBNRm7gXT1UuSpo45pxkA6gfap8yZrH/rTCTpj5rwqN18H63uUrPZS5a4bSXu3mxXzPCilzgAZwANcrfVtSqk+4MvAbuAM8De01pMrNaaVJrSGt6TidZZtZ8xksFsznnWCOmI1e7cfhW0aKII8ilp3V1Sm7n23zmYmJ22zWgscM4NQxGB3grPj+aqnIpzkoQcjFQ+ScCZyDmiNqYxZd6EOwimNQimCIAjtQGsdKV0NrVdvLPRc1BgMI6jOmDuGh+7aw2PPnML1A5VevyLqdO/Ng9Uk9bnej6XIXR8+PtxQ2nujJUx+QGt9q9b6tsrjTwHf0VrvA75TebxhObh/gPsP7GA0U+LNyxlGMyXuP7CDTMllS2ec7TXJOomKvyvKgnR9H9f3KTk+L5yZ4MEnnp9nnR4bGuHBJ57nrs89w+Hjw3WeAdtQdMZM3hrJcmkqkF41KhdhyM6eJLv6kmioWuK2Ca4PJc+n5Hq4no+qaKyLDLUgrG08X+M36YuznmhHknbtmtloTW00ht4OC8f3K15bn94Oi1zZ45F7buDjH7yepG3iViSkP/7B6/n8AwcivR9BgrrP8GiWocszQf6Z13xtjUoO3egJk/cBByu/fwE4Bvzaag2m3UTVBKfjFgXHm6fbcGY8X22EEsbUQrQOWnVDkMg4V866UQ30kRMXqm648LmEFchPX5wqYhsKXUn9tUxFV9ImX3Y5cG0vX3r4To4NjXDo916ujiOwpDUajWUYbU/QEQTh6nB9zTsTedIJi+6kjWWu38j1cidpR+lGNCMVC4T6bMOoeh4m8y7X9wchlUfuuYFH7rlh3nFRHo5UzGyoNRHqUDRiIdnvdrGSM0cDf6KUelkp9XBl2zat9SWAyr8bOkAeJVeqtW4oL3rvzYP4Orirn3uvUPt4ayo+T856sTKsoeSpJnC1eb7G05qtqdg8mdNIWWw/kK+W5EhBWPv4WjNdcDg3WWAkU6Tkrs9y6lZbACxE1JrZjKo+xBzNaNWo3G0RLOV8y/05LJaV9Dy8X2t9USk1APypUmposQdWjI2HAa699tp2ja/tREmjll34zH03NZQk3bP1LX73e283zfoNu3bWuqrmdrjsiJnkyx5nxvNYhmKwK153bNjx84aBFFprcmVvXvfPZrLYv3X/LW1PjtRaM5l36OuMtfV1WmWjzE9hY1I7P7fv3FXdrrUmW3TJFl06YoEnIhkzo06z5lhI7nq5Olo2I1Ny6e0IegeFktFbOm2yjWR9F0Gm5NLXYddJUG/tjFXPFzX2pXQXvVpWzHjQWl+s/DuilPoqcAdwRSl1jdb6klLqGqBhgElr/QTwBMBtt922bgN2zVxSUW6sm3f20J9OMDJTxPF85toQCpgpOHQl7bqM3doOl6WKvLSpIG4Z+JqK7GoQmmjW8bOWKFnsgXSi7RO16HiMZkq4vl5zxsNGmZ/CxqR2fr7n1gMN52e+7AZSx5ZBd9ImFbeWfPe8krQqXb2UjpYhtR+HriSULxS2aJV03OLkdDFIiK+cbyLvsG8g3lSOu9VEz+VgRcIWSqlOpVQ6/B34y8DrwFHglyu7/TLw9ZUYz2qxFJdU6Eob7E7gz9GXgsAyHcuW5nVzq+1wGeZG+BoGuhIMdgcxwSuZYkturtVwj/m+ZjRT4uJUASdCalsQhOWh7PqMZkqcmygwlS+v2+TK5exo+VN7eoHgizz8gaBqYrnDFnUy/+FPZXsrnZdXgpXyPGwDvlr5QC3gD7TW31ZKvQj8oVLqY8A7wF9fofGsCqH86Vi2XA0nDHbFm7q4QleaUgqzoj4Zzq9t6TiZokPR9etCDP/0j16h6ATVGLXXviYQo8qWXHytKTmayzNF9g2kF3TpQbSbEODBJ55ftKjJYimUQ2+DGA2CsJK4vs9ErsxU3iGdsOhK2tjrKLkyKkS81I6WH/78MYau5KrH7N/WyecfOMBdn3um5TW9GdmyR6dtMF2a9Xh0x4NOnNlydEfQ1WBFjAet9TBwS4Pt48CHVmIMa4GlZAfXutLiloHr62o1xEBXglTCqgs3hCGLuYZDyJVMCctQWEbQPKsjZtUZDs3cYjDfPbaYY1rF8zXjuRLZ4tIuQEEQlocwuXKm6NIZM+lK2iQWyANYC9R2+Q17TlyYKhK3jJY7Wj7+9FucHM1jm6qq13ByNM/jT7+17BUfCpgueXUl+tMlj66OpVVitJPVLtXcVERJpv7U3r7IO/faYzpjJiPZcuVsitFMkZhl1oUNwpDF5elS5DjcULraC8q2PvbFl/j4B6/nueGJJQmULGdHt0zRYSJXxlun7tK1RitS1oIQhdZBx95sySVum9W8iNUmylMa1eW3L2lVQxOLldF/8tnTaF/j1GwzKtsff+C9fPLIqy13yIwa91i2VDfskLFsidSWTrTWlH09K4Vdaa7VqqT1crB+/FAbgEbyp/cf2MGRExci5UjDY2KmwXjeIWYqYga4lcqD+w/sqJsk5ybzxExjUV3awn08X/PYM6f40YXJlsVGlkugxPF8Lk0XGM2UxHAQhDVMyfEYmSlybiLPdN5ZtbyIZlLOUQJSyjAiBZqiyBRd5gZO/cp2oOUOmc3GXfY0llExCqCi8wNlTzNaMSxQs00OAS5MFZYkaX21rL7puMmY6xZ78InnF7xzP7h/oK7rZUi+HEhCP1Jz/l29Hfzwnclqpu5C1DbhKji6qUuvEVcrUKIrbtHJvFPXklwQhLWN4/mM50pM5sukEhZdCZvY3E5QbaSZ17NZOKFlCeom2w8fH6Y7abfUIbPZuDtjgTckXpNf4vo+HbZJ2fUxDEVsTpfOXNmjP7183t/FIsZDG1mMKymqtvjkSKYulHFyJMNgV6Vt7EyR0WwJXwcdNh9/+q2qitmhu/fysS++iKkgoq9WHRoqZUaBQFSrLr2oUMxiKjCKjsdYthS0tRUEYV3ia81MwWGm4KyoXkTU2nl+Ms9n7rspcl1qti43em6pY4g6X7NjovphPHTXHr7w3BkKTlCBVntz6PvNu3S2CwlbtInFdkfb1dsxr8PaeK5EpujWHZspuoznSozMFLmSKdV5FR575hSPP/0WEHgp9vWnsEyj2r1zIXyt8XXQ/KpVl15UJ7pmx3i+ZiRT5OJUQQwHQdhA5Msul6YLnJvIM1Nsrzex0doZej2bdciMWpej1uwo1AJjiDpf2I6g0TFR/TAeuecGbtjWxZbOWF0oZktnjHQi+nztRDwPbWKxiYSN7twncg69HXbdsb0dNhM5p/plG16SViU49uSzp6veh0995N3VSev7mvICPendSg/4h+7asySxkVaOmS44TOWXnhD555czPPf2OL/0F0TJURBaZoUig47nM5YpMZkrk07YdCWsZe+jsZDXs9G61CxMDDR8Lgq9wBiivgNq2xE0GndUP4zwtQa7rbrjfumOazly4sKSvL9XgxgPbWIhd1YtnTGT4bEcvtZYhqLs+mSKLnHLqcpHb03FcT2fsTl36k7lS9jxXO763DNV19ij997Iod97GV/rapvtZoTWbbsoOh7juTIlp3Udfc/X/NnbY3zl5fP86MIMMdPgnp8cWHI5lCBsVt4ezfKZ//Vj7tjTx+27+9qu1ur5mql8memCs2CpZ6sVAwvJMj/+9Fs8+expcmWPzpjJQ3ftaboua2ioo9CMZmP4ja+/3nI7gqW+1s07ezauPPVmYzGJhLUaCYNdcS5MFXE8jW0QdLqcDlplh9LT/ekE43knMhHSVMzqLNx7Iweu7WUkU+TydJGi482TtoYgUTIVt9pmOPi+ZiJfZqbgLLzzHLIll2/96BJf/eFFLs8Uq9v39ncyMlMS40EQWsTTmu/++Sjf/fNRAK4fSHHH7l7u2NPHT17T1bYum41KPTtjZlWJcal6MVFez8effovHnjlVrVYoOB6PPXOKa7rikUnhk7lSQx2FhYgaQ5TWxL6B1JLlpKOOWw15ajEe2sRiEglr3VrDo8EkQwclP4EWlGYsW8IyVcWo0HQnLKYK811ppqEYy5bZ25+quuHCMaQTVmSP+zAZpx3kyy5jmXLLCpEXJgv8zx9e4NuvX67G8hTwF/b2cf/7dvELB3asC919QVhrDKTjvP8ntnDinSkKjsepkSynRrL8wQvn6IyZHLiul9t393HH7l4GutpjnJccjxHHwzKCPhrphLXsejFPPnu6YjgExpChQtVMh61po+G6/LlvV3o11shMN3PZLrQCRWlNbJSqMjEe2sRiOp3VSqjmyh6GCrwHoOhNBp3Vcl4g0fzQXXv4w5fPs7O3g5nizDz1SM8POmEOj2bZmopx8soMh48PBw1vSs1DBc8NT3Dz0MiiLtJa12IqZpItuYxWhKv2bu3k1z68n7v2bWU8VybXgkSr1pofnpviKy9f4Pnh8er1lrANPnzjID9/YAc7eztQSonhIAhLpKcjxmd+7iYcz+f1C9O8eGaSF85MMDyaI1f2+P7JMb5/cgyA67Z0cMfuPm7f3cvNO3uWvQzT9WdLPc+M5+jtWFyYdzHkyh4GmpLroXVQjm4qKHk+j957Y2SYoZHU9NmJQsPXMBbISM+WPTpsxUxp9uapK25E3siF/OpTJzj62mW8Si7avTcP8vkHDrT+IbQZMR7ayEKupFq5UcVsWY5laCYLDqahSBiK/nScIycukKrUACdtk0LZmydcAkFuwbmJAqapGMkU6YyZTOWjQwYKFu0irHUtmgreupLFh4qoieLkSJZ/+kev8M/+j/3cvqdvUZ9R2fX5ztAIXzlxnuHRWe34gXScv/beHXz0PdeQSsg0FYTlxDYN3nttL++9tpeH797LaKbES2cmeOHMJC+fnSRbcjk7nufseJ4/evk8Ccvg1mt7AmNiTx87epILv8gi8bVmWzrBeK5EZ9zCqPTxuZqKgbhpkHdmZZ61BkdDh21ErstR2hCR414o6dv36wwHgJmST1ci2hP7q0+d4KuvXKo+9nxdeXxizRkQsiqvIrUd2WxTVasiPB8sExRB/4rQhaeUwvH8pmEIT8963WrDIVrr6nO1U34gHV+0i3BumCU8T2DwBGfOFF2+9MK5BY2HiVyZo69c5OirF5mqyYd4z44ufv7ATu66fmsQxhEEoe30p+N85D3X8JH3XIPna968NMOLFWPircsZiq7P88MTPD88AcCOniS3V3IlbtnVM09noFUeuH0Xjz1zklzJJWEbZEs+ng9/f4kh1b5Om/yUNy/q0NdpN9wfokPNUSwUfJiohJerapBBW6Lq9kYcfe1ycMyc9t9HX7vM5x9Y4AVXmEUbD0qp/Vrrocrvca11qea5O7XWz7djgBuJY0MjfO7bQwyPBXfYvq/p67DJlT1K7mxVhAZcT9OfskkngsmetE2mC041S/fyTHTvCk0gZ/qjC9MNnwuxzaBLZ5gNfH6ywLEm4Yu5YZaQSq8uUOB5msszjd18ACevZPifP7zAM0Mj1QvTNBQfeFc/P39gB/sHuyKPFQSh/ZiG4qYd3dy0o5u/9/49TObLvHx2khdOT/DSmUmmCg4XpgpceKXA1165iG0qbt7Rze2VCo7dWzpaDi3esbePj7OPp148x+WZAoNdSR64fRd7BlKMZIp0JRpXaTSqqHjknhtAKfpTNuM5B18HOQ9bOoPuxFFhgahQ89/97y8u6XMsuT62EdzQhaETSwXbowhL2OemRSxU2h75ObSRVjwPfwCEfpPnan4H+E9zHgtzODY0wiePvMpk3qmKN7m+ZjxXZmsqTskt132xa2Ai75CMWdVqi1D85OD+AW7+V3+8oGW8EFrDaLaMpYL4nYKm4Yu5YZa5r6x1sPAMdtW7ND1f89zb43zlxHlePT9r0HQlLH72lu3ce8t2+tPxJb8PQRDaR29HjHvevY173r0NX2tOXsnywpkJXjw9wY8vzeB4mpffmeLld6b4z98bZiAdD5Iu9/Rx4NoeOhfZQOuOvX3csbfeY6m1Jlt0yRZdYpZBV9ImFbMwDBVZUQGzIYjB7tmwR77sMpUrNw0LLGfVQpTUdGcTL02oKtloexTNPod2GhCtGA8q4vdGj9cUq9FxbC6Hjw+TKbqYhsJQCs/XaIJQwpVMvRfBVIG16vqac5N51FSQNXzfLdur76crbjJzlS2rw+6argbT12zvSzJTcPjYF18CmGfBhncTmqB5i1NjQPuVFuBdSZsHbt8FQK7k8q3XL/PVH17g0vRsydN1Wzr4hQM7uOfd29ZFe19BEAIMpXjXYJp3Dab523deR6bocOKdKV48PcELZyYYy5YZyZT4xo8u8Y0fXcI0FDdu76omXv7EQApjiQnPZTcQnppQZdIJi//y/eGGFRVht8tGIYjJSog0KizQ6A5+qTx01x5+++mTOF59iPlXPhB9zt6kzXiDHLXeZHS45clnT1fD0q6efW+1woHtoBXjYe6NcdRza4ql1g8vN+cm80HLVtPA8zVlr7HrSgExy8TxfFw/kI3utE3SCYsjJy4AcOTEBeIxi/6Uz2i2df2Ehq+rFJO5MtMVgyRuqXkWbKbkck13nLFsGcfTxEyF52m84ARc19fBw39pLzv7kvzH757iW69fJl8T3vgLe/r4hQM7eN91vVIxsQlopR34mc9+tI0jEdpFOmHz0zf089M39KO15vRYjhfOBCGO1y9M4/qa185P89r5aZ589jR9nTFu3x2Ug77vul66m3wpRuFXmunlyh6WEXgnwvXEUEGlRashCM/XTe/gl8Jzb49Fbo/8Uo9YFpstl5miW//lrGe3t5NWjIedSqnHCd5e+DuVxzuWfWTLxHLXDy+VXb0djFV6UjTTPai2ya7MgM6YWc3+zZddnnz2NP2VJMfgvQT5B4tRkYwiKBFVVcPBUGAoo86SP3TwJxhIxxnNlNhVkwFdcDy2dMb5f/7Gzbx6fpqvvHye//12TamlZfCXK6WW1/a1V2tdEITVQynF3v4Ue/tTPHD7LgpljxPvTPLimUlePDPBpekiE7kyf/zGFf74jSsoYP816YquRB/vGky3lCSdtE1KrldpEhXkjHm+prOy1jcKQZiGapg/YBoqUhuidU3cgOdOT7a0HQj0fExVHQMEY2jWYsCovKe53pSFSkmvllaMh0/W/P7SnOfmPl4ztCIT3U4O3b23mvOwUIWP5/uV/AHoiJl18qb5skdvh13dFk6xq3H9GErh61mDxtezCTqOp3E8l188/Dzv3dnN1169yJWZYjXZqCNmcueeLRz6Hyc4NZqtO29fh80/+sA+Du7vv4rRCYKwHknGTN5//Vbef/1WtNacnyxUcyVeOT9N2fV581KGNy9l+OJzZ+lKWLzvut5FS2f/jfft5L8/d7buZkwBv3THLhzPx26glnnvzYN89ZVL8xIS7715kKOvXUbN0YZY6YKvmGUEZfi6pnOmpqqx0SgE3xmrhLDnvKfONnc2XbTxoLX+QjsH0i4WIxO9EhzcP8Bv3X8Ln/v2EEOXM9W/c1jGUzuZlVJ0xAxipmKq4GAQyKWGoY5zEwVsywgkTyPCH4tBqaDE0lSKYk3/bgV1YRUFjGdLfO3Vi5Qdr+pa87RmuuDyRyfO153XDHp1MV1w+A/fPUlHzJyXCNUqMcuoeFskR0IQ1htKKXb1dbCrr4NfOLCTkuPx2oVpXjg9wQunJzg3WWCm6NZLZ/enuGNPL7fv6ePGBtLZ7xrsosM2yDs+mkp5um2we0uKcxN5OmIWXUmrbu2/79ad/PGPR+rCqR0xk/tu3cm337hCwZldB7VunLzYTvYNpDkznmWm4FZvGLs6bXZvSUWG4Ld3J7CMElOF2cqS3qTNu9pcudZKqeZdwF6t9Rcrj48A4TfCb2qtn1nEOUwCL8UFrfVfVUrtAZ6qnOcE8Le11uUW30NTFiMTvVKEbrRjQyM88qUTzJQqdciVCWoo+Mcf2scj99zAsaERDv3eywAoo1Lqg8IwNL4/e8xV2A6YSrG9O8GVmRKWoei0DaZL82ujezpskrbJlZkiPpoO2yLjunUGT0/SJltyUEpVE6J8X5Mruzz14rmWjQfbNEjYJsmYSdI2RfNBEDYQcdvk9t2Bh+EffgAuTxcDXYnTE7PS2aNZTo0G0tkdMZMD1/YGxsTuPrZ1JXjqxXP0peLsqEm6Ljhedb3Jl13yZRfbNOhK2KQqMtjXdCfqDIowjL01FefcZKEu7WClk/miOmc269KplCKVsOntjK3Zrpr/GviVmsfvAv4u0An8c2BB4wH4OPAmEJpEnwM+r7V+Sin1n4GPAb/bwpgWZDEy0SvNwf0DPP7gAX7jaz/iwnQRraHDNvkHP723mkhzcP8A6YRFvuTi+JqYadCfjnN+Ml+JZWlKrq6b3FFlPlHsG0iRLQXJNjt6EiilyJXzuHPOUSi7jOWoxt1mvNnciO6kjWUoDEMR9PEKqkgUgQdC+zTVfQgJjYWEbZC0zbY16BEEYe0x2J3gZ2/Zzs/esh3H83nj4kzglahIZ+fLHs+eGuPZU7PS2aOZEj0dNr7W1RuWhG3MW28cL5DBnlhABlsDA6kYY7ly9Q6+vzPGSHZZ72ebcnD/AO975fw8HYpQPrtRCL5W/2etdtXs0lr/uObxSa31ywBKqX+30MFKqZ3AR4F/A/wTFaTHfhD4pcouXwD+FctsPMDqdBxbiIP7B3j2Ux9qus++gfS8kItlGHi+j48iZhqUPb9qQJhKEbcMfF+jDIiZxrxM3JCOmMm3/vHdQNDj/vRYhvGsgzIUttbVMkwDKLqaojtb1REzFT0dMboSFiXXZ0tnnJmig2a25FQTlA3Zinm6DxCEIQJjQTwLgiDMYpsGt+7q4dZdPTx8917GsqUg6fL0BC/VSGcD5CvJ4h0xk46Y2VBnJkTXyGB3xKxK2Xx9GHskU2Rb9+zx+bK7ZONhqZoNR1+7HCRuWkGDxKOvXWbP1reahuDXelfNntoHWuufr3m4bRHH/w7wz4B05fEWYEprHdaTnGcNV22sBo1CLumEVZVzVgaYWs3qNfgapQK9hZ64zd+58zp+5+mTDY2HvmTwp3c8n1+8bSef/MpraDQGinKtfkPNMQrojJv0JG2SMZOiE5STPnD7Lp44/jbGnP0huHgeuH0XtmkQr3gVxLMwn1bKGgVhqRgq+HJ2fb1uujtuTcX5yE2DfOSmwTrp7O8OjXJ+qoAmKM8MVW8dT/P4d042lM4OZbDz5UAGu+QGMtgP3bUH01ANQ9xRlWwL3e70Ji3G8/PLJXuT0V+7URUfzbQrViMED60ZD0NKqY9qretWOaXUXwX+vNmBlX1GtNYvK6UOhpsb7NpwNiulHgYeBrj22mtbGPL65uD+Ae4/P8Xvfu9tCo4f1Mj2Jkk4Hp6vcXxN3DLYErcYz5Vw/SC0EH6w3/zRpXnNLEKZVpTi6CsX+G9/doZL04Uapco8Wa59AAAgAElEQVTmWu4D6QTooIfFYFeS9+7q5qkXz3FmIo9pKgxfV8MetoJ0h839t+3c0MbCZp2fwvpg7vzcVSmZditaMo7n43oax/fxfI3raTxf469B42KudPYzb47wxefPMpIp4nq6qtr7tVcuzpPOvmNPH7fv6eXjH5wvg713IEVHzORffGQ///25s3Xu/4998aWG5Z0LlUIm4zZG3q27oTKAjni0tkWuXFnb5whL+TpauyLMo1tpIcRWjIdfBb6hlLqfILkR4H3AXwT+6gLHvh+4Vyn1V4AEQc7D7wA9Simr4n3YCVxsdLDW+gngCYDbbrtt7c3oNnFsKLgwQkEmgEvTRZSCLZ0x+tMJADJFBz8THBMzg5rfsWyZyVwgPa0rk3x7d5J0wiJbcjGAf/etoaBNrbP4SuaZQhnbMvnHHwpyMx575iSWoYiZFQ+Igmt7knR3xMiXXQbSiQ1tOMDmm5/iJVlfRM1PyzSwTCJVXj1fBzoHvsapGBSuHxgawRf1VWRrLxMffPcAH3x38CUZSmeHiZfNpLN/7sB2DlzbS6oina21Jldy2TeY5v++/2a6Ejad8cBDakJDrYeF6r4KJWe+JxbIl6KF/aJ6WITbG4UnVksIsZVSzVNKqZuBvwncSHAj+j3gSYJEyH/Y5NhfB34doOJ5+ITW+m8qpf4IuJ+g4uKXga8v7W2sb6KsxsPHh5nKO9WwRC2XZ0qMZcsY6LowQ62YiFctNQoSK89O5IlZClspSp5Pk/4sDTEr6m1bYxZffulcVR9iPOvi+kHlh6FgPFfGtoxVdakJgnB1mIbCNKK/IrUODYrZf13Pr/l9ZQ2MWunsv3XndWSLLi+/E+RK/ODMBOOLlM4OEyzHc0FFQ6Tq4wKeh8mI7plR2xdDo++Kw8eHuTKdp1Rj4cRN2i6E2FJL7konzf+mlHov8CDwfwGnga8s8fV/DXhKKfWbwA+B/7rE86xbmlmNr1+Yamg4hDR7LmTuHp6rKbdYgKQI9CAMRbUl+Fi2RMHxmM47GIbCMhVKBfHGguMxkE6selWLIAjtQ6ngurcWuAUPwyOur/Eq4ZHQsPAqhkc7SCWshtLZL56Z4Efn50tn93bY1fLR23YH0tn5shup7tisOyZEV74t9e1GfVdcmMwzd4glD146M760F1okreg83AA8QGA0jANfBpTW+gOtvKDW+hhwrPL7MHBHK8dvNJrJZ+ed5pNzKZLUrUqtdthBcpWhFFpD3AqSjHb2dvDGxWlQVMukLEMBPknb5EsP39niKwmCsBEJwyNR+H6NQVFjXIT9fZYjsXMx0tmTeYc/+fEV/uTH9dLZzajtqzGXUAp7rmz0UivLor4ropSrF/j6uGpaSpgEvg/8rNb6FIBS6lfbMqpNRCifPVNwGMuWqqpiIxUJ6NWmu8NmLFPG0UFWcsmDt0dzlMpu9aL2/RopVajmZwiCICyEYSjihkmjzt1a14dAwvwLx/Mpu/6SkzobSWe/eGaCP/3xFd66kkVDVTq7Ge9M5HnlnSl+/wfvcGEqz7V9nVWPazMp7KVwbjJPyXE5PZar6lBs6Wy9sdhy0Yrx8AsEnofvKqW+TZCnIN8SV8mu3g5Oj2UZz5WrMtRF11uUcmS7TYsO22T3lhS50nS1Q5simLSXM2WUglTcpOzqqtGTTtjs2Zpq88gEQdgMKKWwTUWQ0znffeFVqkXCihG3ktRZdv1F33yF0tmXporMFF229yTQWjNTdCk4zc/z+8+f5eirF7HNQD7/4nSe3/j66/xr/8YlvuMm+PVdlH3NsnVVXgqLToPXWn9Va/2LwH6CsMOvAtuUUr+rlPrLbRrfhufQ3XuZzM/qNmhgDSQxo4B/8NN7+dLDd3Lj9m7ilkG8IuwUs0zMiqshX/YZ7E7wrm1pBrsTxCxTkiQFQVgRTEORsE3SFXnm/nSca7qTXLelk91bOtnRm2SgK0FfZ4xUwiJhm9im0TB08NSL5wKZ/phFKm6zvTvJ9u5E09d/4vunuTJTYjJfZrrSh0gB/+GZU3z91Ut1+4bhi6OvXY48X1ei8f18V8JiojB7A6fU6t+5t5QwCaC1zgG/D/y+UqoP+OvAp4A/WeaxbSiiKioayVC7NW1jr6bV9tWggd9++iSff/pktXFXwg5sTdfz8bTG12CjsQ3FdMFZE9LfgiBsHprpG0SFQ8Jj3pnIsbO3g7/3F3dz509s4UqmSDpuoZSqhmTDNa8ZGsiWPLKVcoew4myuwyIMX3i+puz62Kaaly/RlbSDDplz6E7aXJwuVl9vVb4U5tCy8VCL1noCOFz5ESJYqA53rgz18Gi2qpa22nOkdqKWHR/TUDg1V4VpKPKOz2fuu0mMBkEQVoyl6BvUHtPbEWMsW+LffmuIR++9kd1bOoN12DbROihvz5eal1Vu7bQZy9WHDnxNXdfORpyfzKOUImEbJCwT2zKwTcVEttRw//FsiXnJE6vMxlbvWSPUZskG7bYtbFNx+PgwEIQuHE+TL7v4vk8qYa66S6oRPvXloZahGOxO1L0XQRCElWChdbXVY2rXYYCi40VWMoRkS42NhGbrtwKee3ucfNmlUPaYzJcZmSlyYbIQWWGXd/wFxzIXu82J61fleRAWR1hRUctMoczwWI6f+OffpMM2uHvfVi7NlLg4VeCarg7es72bp4dGFzx3WDq5UoTzN2EZdCdtRjMlSq7H+ckCx4ZGxPsgCMKKcG4yj6kCT22YsL01FeP8ZH5Jx0R1tHxnIvp8TkQyparEmxs9q4F/8bXX66Szb9/dx+4tHa19ALWvR/1rKZauJ7FYxPOwAuzq7aBQIwF9eSrPaNYJan5VIKr0rTeucMuObv7g79/JA7fv4o1LGaxFGI7lFTQcDBXEAC1D0Z20mayoXxoqEIj69NE3ODY0smLjEQRh85KOW1yYKuJWvuhdX3NhqliVnG5EKmYGx3gaUylcLzimM2bWdbSMW4EoXrPkRiByjV5o7TYqgnqhbPbHvvASD/6XHyz0liOZaydoIN7mtgBiPKwAh+7eS9n1yRQdSo5XjZHZhkIpA9MwMBT84cvnAfjic2fJFt1qg6lGKII/3kpGwbZ2xthW6acxkikRmtYa2JaW8IUgCCtHVTxK1/zUbm9ANUFR1fxUttd2tDSUUfl3gTFEv1DTtflr/+f7+Vc/+5P8lZsG2ZqKAeGaGs2tO7sabo8yVLqSFiOZIlP5MpmiQ9Hx8JfRHSFhizZRdn0KZY+i67F7ayf/8OD1PPXiOc6OZ6uTyvGD5hOK2b4R9/z29xblbtreFeNSprxi1sNAKlbT515zdiJohWubiq2pBF1JuyK2Eu3iEwRBWC6yZY8dPQnGsuVqCGIwFa8mmzciU3LnH9MVJ1tyg+O0plDT0XKhtIGoPISF8hOGLs3wtR9e5NJMgR3dSf7WHddRcL2mN18DXUmu63M4O1Gobrt1ZxeXZkpM58sUa+42ExWLItugcsMyjIqsuKr+HjONyAZpUYjxsEx4vqboeBQcj0LZw5mj8nTH3kDm9LFnTsKcxigaql6GxRqGvlIkbbPphXK1WBVXYMxUNYZDIDfblbDoT8erFSIABcdjZ+/S43aCIAiLZVdvByOZInv7Z0Xpwk6+SzlmJFOiNMfdu5AREDMVhQaLdtT2kP/w3VOYhqI7YTORL/Pll8/x8Q/ua1qa/yc/vgIEzpJ3DaaDhl57evnN//XjOsMBmPe4FtevNEWsKRJJxa2WjQcJWywRrYOs3PFsifOTec6O57gyU2Sm4MwzHEJCEZLlyIGdKbh0xFr7Y7eK52tMFbS6HcsWeXskw+sXphkey+H6gaTr+ckcb49k+PGlac5PFvipvc214AVBEJaDQ3fvZbrgcHIkw9DlGU6OZJguOE1F6morKsI1POz+q5fg0t+aire0PcT1fUYzJU6P5xjPlvB8ny+/dI7uROM1PWkp7tjdi2UE4ZChyxm++PxZfuVLr3AlU254zGS+8fblQjwPLRCGIgoVD0OrDVsuzRTwfX9ZIg25skd5MRrWV4EGdvYmmciVmMg5OJXkTANwXJ+4bTCZdzEItOLTCYsjJy5w884eqboQBKHtKAjyrrQGvfCN2cH9AzxKULJ5fjJfJ2wXVTnRjOlCY3noqO0hY5kyhqGC5lkaJnMOvs7XJdbX4mnNz793J+9M5Kutz7MlL7KzsgLKbrCf1abESTEemuD7QSVEvhyEIpbam15rzUtnJ8mXvWqPiFZpVPpjoDCURkeUBF0thgpCFEoZ7OyNc3k6yFI2DIWvNfmyh12Jl4VuwLAjqBgPgiC0k8PHh+lK2gzWhFQXs/6Eyr5zWcoaGoaN53bOXDCcXNONWCnwVaA6GSEbQdkLPNe2adBV8U4MpCFTdLg8U5o3/vD3n/tP/5v3XtvDHbv7uGNPH9u6msttt4IYDzVoras5CwXHu+oyyKLj8fSbV/jKiQucHb+6RMJGTo5Smz0Pvobh0RyaSk6H62MbNRNeg/Y0jucxPJplaypOOmFJ0qQgCG2nkX5O0jZXdP0Jqxfmrs8LVTV4vsb1PDSzvSoW6kZ8eaZAek7vi1TCoqPoRhor+bLHn50a589OjQNwXV8Ht+/p5Y7dfdy8s4eYtXSvxKY2HlzPp+SGPx5Fx1+W3vGjmRJff+UC/+u1S3U65bfu6uHSVJ6JfJkI79SaI/w0gjANuAQVFm4lk0gTeChcT3NxusAWNyZdNQVBaDth8uNyJW132Cb5FhfmhG1QaKAKGbU9pJGo09ZUfJ7UdS27t3RyZaZI3DaqxknR8dnWlWAkU6xTu0zFTR75wD4crXnpzAQvnZ0kU3Q5O5Hn7ESeIy9fIG4Z3Lqrh9t393HwXf0MtOiV2FTGQ9HxKj+BsbDYlq2L5c1LM3zlxAW+99Zo9dy2qfjg/gF+4cBOrh9I8cLwBI89cxLH9RjPOdUJ1GoDLNNQ+L5eMZ0HrQPr2PM1SvkVcSiqfeWVAfgwmXf4rHTVFAShzRy6ey+fPvoG+bJL0jYpOF41+XEp9HXa5KdaMx62puKcmyzU5Vromu1RKKWImYG4ntbhutrc8/APfvon+PTRN3A8n7hlkCsHOQ+2oentiLG9ezbZsuB4fPP1y/z2L97CR24axPM1Q5dneOH0BC+emeTPL2couT4/OD3BD05P8P9+9xRnPvvRlt77hjUetNaUK56FYiUMsdzGAgR/9O+fHOUrJy7wxsWZ6vbeDpufvWU7996ynb7OGC8MT/BPvvsql2YKdMYskpaBV8mp8HQQ/0onLMayi8uQtU2Fr1TbkybnogmU0UK64yauhrIXhDQ64pbkOwiC0HaaJT8CPP70Wzz57GlyZY/OmMlDd+3hkXtuiO7EqRTdcZPpmjv4uY/nogk0cMYqXTQNBf2dsQXH3mkb814nu0ATrkbv9+G/tId/8fXXmcmXOFeeXZc7bVVX9Wcaihu3d3Pj9m7+3vv3MJ13eOnsBC+cmeSlMxNM5psneDZiwxgPruf//+y9e5QcV33v+9n16Md09zw0o5FkPayRZSNjI2xhHgbhKMZZFzARITjEJhBygrFvLlnmkOSucHIODtfJyjXrkONjJ7mJHUGAkOAQB8cihGTFNsYIbIgt/MBY2EZjWxo9Zkbz7HdX1b5/VFdNdXd1T3dPz3t/1pLHU12PXV2/qfrVb+/vd5MvqyEKlpuBdqILoh6z+RLffPYM//yjkQpnsAs2Jnj/vm1cvWfQ70/yqg2GJuiOGeXuEbjjVy/3A/2RY6P83n1PN31825EYmoawl8YnyptdUwCGLijZrrlV1nI4rydOd9ycV2OtUCgUnaTe4Me7HnyBOx9+qewY6b6J3/nwSwyPp3ny1enQmThTUYMz03mihuZXBDINuh5grutkU9WgzcFUrGHloTohmS7YpOLz38nDzrfwj0+RLlZumylJTL1+MtLTZfKOizfxjos34UjJSIO21mNJkgchRAx4FIiWj3mflPIPhRBDwL3ABuAo8GEpZVvi1IlMcd7MrRO8OpHl/qMj/PtzZ8iXB1QK4K0X9PP+N2zj9dt6aspPnr9D3NTRNEFP3C2xBUcF3/3o8abbr+G9/TsNJ2DpNBLXOMrQ3D4Ky5ZowHi64CcU7ZYMFQqFolMEraahPC7LcTj8zBl29nf54yS6Ioav0Kiwuw7+bEDDrhPp8NjwZM02XndvdVfHRIPxDo2YzIU/N6bzzXXBaEJw8ZZw6+tGLFXloQBcLaVMCyFM4IgQ4lvA7wB3SCnvFUL8FfBR4C+XqE1NI6Xk6KtT3PfkSX4wPOEvj5s673rdZn758q2c1xuvu/3pmRw9MRPT0EjnLcbTBYq2wyvnMrzrfz/KbMFibLZQ11yqpj3ln5Y9N+ahPORg0THKagtdE0jpzs+RtxwGU7GKkqFCoVAsF5miTbWQwJuMKl7lpOgpNCTQ12VwLlPyuyD6EyZj6foP9UZdJwf2DPKG2/6dc9m5h3t/l8FU3kZHVrhX6sJVz+maCO1e18v33bCumHq98RLY1B1jOufOa9FpliR5kG5Kly7/apb/SeBq4IPl5V8CPsMKSh4KJZsHnx/l6z8aYXg84y/f0hPjly7fyrsv3UyiwQxu4A6M2dHXxUS2SCFvcWo6h4Y72NGW8OJomq29sZamUNWEa5vqVgLKA24WofTgVhkEBcvxJUXewEkp3enAN/fEGEzF+OpNb+l8AxQKhaINEhG3ChCc2MqR7kM4V7JDFRqTmQJnpvOY2ly3xWR2/mpwva6TT957tCJxADiXtXxjKAH+SHlbQpepYdsOYY95Q9TvivGo9prQNUEiapCIGhQsm5mcRaZg4XSoO3/JxjwIIXTgSWA38BfAz4ApKaX37Z4Eti5Vexoxni7wwFOn+MbTpyqklnu39fD+fdt46wX9fibYiK6IQX8ywsd/fje3Hn6O0dm8HzCOdB/OuiYYTxfZ3BPjxES2qSQguE5YwtGqcqPe9rYjMXThT3erCXCQrkxIQnfCVF0Vio6w81Pf7Pg+Wx09rlg73Lh/iDsffgnLcfxuAkfCwb2befLV6dBuhs/+2zF348Bsmwu5kXrTeVc/1L3KgvT/47IhbjBaZ8C8pH5XjCjfn6tzgoN7N/v/HzV0NqZ0+hMR0kWL6Wz9aRSaZcmSBymlDVwmhOgF7gcuDlstbFshxE3ATQA7duxYtDa+cHaW+548ybd/Oie1NDRParmVCzelmtqPoWlsSEb8eeW90tbNX3kSR0qiuoZVfqtHuEqFVMxkW1+cU1P5lmxSF0FAUnERLFviSOlXRroMzZUZGRo7+5Oqq4Kli0+Foh3WY3zecs1FAKFqi0/ee5TDz5xx5+7RBAf3bubAnkH+xwM/brnbAuqrOhqp+zYmzZrjCE1rOEtnpmijISlYtl8B1gVIBHs2JTh2dq46vmdTgjuu31ezH00TdMdMumMmmYLFVK5Eoc0ujSVXW0gpp4QQjwBvAXqFEEa5+rANOFVnm3uAewCuuOKKjj4ubUfyvZfG+aejJ3l2ZE5q2RM3ee/rz+PgZa7UshmEEPTETfq6zJpBkwf2DLJvR59vanJ8LO0bLUXK3uOGrrF7MMnx8QyOlBVjGlphoV+QV3mIGppf6pPStaXuS0S57eAl6z5hCLKY8alon1aqGWu5SrFe4/OWay7ykwiPux58gcPPnHHf4A2BI90KwdDACyQjesvdFo26EuqNXwDojkfY3DNnZjWfQsN2JF0RnWzR9qvXUkJJgqFJXhzLYurCr7K8OJblrgdfqDn/IF6XRr5UOwt0MyyV2mIjUConDnHgGuCzwLeB63AVFx8BHliK9gCkCxb/+uxp7v/RCGdn5qSWuwYS/PK+rVxz8aaWrDvjEZ3+RLTuNo8cG2UyU+DlcxlMTSOqCzLeBdMF4+k8pq5TKBaRUlZ4KSw1nl2q3zcm3ZncNqViGLqo6x1fVz+tUCgUbdLJ+8qhI8NI6Y43s+Rcl8KhI8Ns7Y27/kDeZEFi/mmnDx0ZdsevBZaJ8vKDezdz/1Ona7oTrhzqY2S6ENp18tjxc3WPtSFukC3aNd0dtgOGXtudcejIcMPkwSNm6i1Pxw1LV3nYAnypPO5BA74mpfwXIcRPgHuFEH8M/Aj4/GI3ZGQyx9d/NMK//fiMP4OZAN68awPXvWEbl2/vndfpK4iuCfqTUb+LIoxHjo1y6+HnMHXBtt44p6fzTBcc9PLEU7YjmciUePelGzj8zGl0ITA10dYsb53gvN4YH7hiO3/xyM9wpMTUBQPJGN1xEyllqHd88Byr9dMqgVAoFO3Q6fvKbN6qnEBKzi0fS5dfIr3cwRsl3oCZkIkOZXm5221Q20Vyx/X7/IQozNyqHjnLCbW19qYICKKJJibnWiBLpbZ4Brg8ZPlx4E1LcHx+dGKKf3pyhMePn/O//Jip8c5LNvPL+7a25YeejBr0J6PzDp68+9HjmLrwR/iOp4tInJrZKB86NoapaUjcpKTkLP0EGJqA7RsS3HLNRTx2fKJp7/jqcwzqp1XyoFAo2qHT9xWt3JVQPYhR0wRFy0HTBBFtrt5gOQ72AqrAd1y/jzuur11eT6HRiJLtDmA3qtpXsqU/dsLDka7iZDFZMw6TYRQth4fKs1oeD0gtN3VHed/lW3n3pVtIxlr/Ckxdoz8ZqXioNqJ69rei7YCUZIo2Px6ZnpNBBn82X/zoKP0J068shBmgzORKmJpg/2cfrighnpjMogs4PpamaLuJ0UAyombYVKwK1PiIlUmn7yuJiO5WC2TtclMX5ErujJjemIf5qKdsm+/23U5XTMTQyBVtdwC71z4JcVOjYDmU7LmXTU24ipPFZE0mDxOZIoefOsXhp08xlZsbKXvped1c94ZtvG33QFNSy2oaDYhsRPXsb7oQ5AOzUob+XKYhDyVbsnvQrSxUG6Ako4Y7t4Uja0qIyYjOS2MZdCHQhTvr5shUnt0bE8tzIgqFYtXT6fvKJef18NMzM0zl5pQOfXGT12x2HRaHx9PM5i0/UUnFTM4ExsRV48nYw5bXo1FXTCMuHEzx8rk0M7m59nUnTHrjEUYms6SLtn9OyYjO3m29TX0n7bKmkocXz85y39ERvn1s1L+ghiY48JqNvH/fNl6zuTmpZRhRU2cgGSFqtF4Kqn6Dt53GI1u9AYuCzps/zecBMZ23KnwbguW1G+55nKLthJYQ/WSqSiPdSpKlUCgUQTp9X/HuxX2JSOhMnLcefo7NPUbFZ40ISxwaLYfGXTHNtL26fVJKNnbHOD9QCV+KLuNVnzzYjuTB589y93d+xtFXp/zl3TGDX3z9ebz3svMYSEbb3r8mBH2JCD2BbodWObBnkOtOTnHoyHDNgJ0wJItXefAG19SNbem2N6ys5nW/zORKvsV2RNeYzhaJRQy29sYYTxf95Zu7o0sy34hCoVibzBasjt5X5puJM+yz3/jif7bd/jAPiEZdMY3sqQ/sGWTrd16qmC/jyqE+TkzlK7rFYc5yezFZE8nDp//5x/7Mljv7u3j/vm1cc/Eg0TbkJ0G6IgYDyQiG3rxkM4xHjo1y39ERuiLNZbOLjSZEjUWpX5Eo26Ded3SkpqyWjOiMpwucyxTRcMuIRdvBciQbUzGKtuMPAAXULJsKhWJBeF2+nbyvNBqs2OpAxnovYloDO+nemMF03grtipF13uqkI/nkvUdrJtp6bHiSgYRJztCaGtjeSVZ98hAxND7y1p18/2fj/NJlW9m3ozWpZRjNyC9bwStTnUtbaAgiuvvQXQ4E7pgLoVORxHj/1xs3OHRkmI2paE1ZTQjhz/suynNqCAQbEqbvTRE6u5xCoVC0QcNZK1cAG7pMxkNmw9zQZda1k57MldC8fumqrph6TwWH+nbXE9kSXVFzyb+jVZ88APxfBy7gV96wrSMl8mTMoD8xv/yyFU5MZimUrEXX3TaDxFV7VOe3moCBRITB7hjPn5llR8jMc9O5EqmYQbZgUXIkEV1jY8pNsqZzJf7ovZe2rF1WKBSKeszXzdAOjZQOYZ81IhYx6CpYZK25O2qXIYhHDCan86F20o6EgYTJeKboD3AcSETmfX75c2JU3bwdCbcdvGTJ771rInnoxKA8U9cYSEaJL4Y21nHm9UfvJGEyo+BASW/cg2ekFjU0LirP25EtWv6MdPXKYNXeD9mixba+rra0ywqFQtGITt5X5lM6hH3WiGRE54wDUX3O0rroSBIRnaihhdpJC+FWC8zANhPZEhcONh6b10gWuhz33jWRPCyUnrjJhkRk0ZQBE7mlHTQYNtiyepEuQApXZuQ4DlJKv9x14/4h7js6UrcMVq+MqOypFYq1xVr7m55P6RD2WSOEEKGW1kKIunbSWtDQJ/CZnGeUfH8ywnjIrJv9yebmXuo06zp5iBhutaEdX+9WKFgOpgal5RnmAFTGalR3+9aiukZfRGMmbzOdK1WUu/Zu621pRDKEZ+3KnlqhWJ2sRcv5asM+mFMmSAj9rBH1LK3H0gXypfDEwwbOr1aQJKMrolu7FdZl8iCEoK/LpCfemtlTu3jdAJqQizKFdjUXbExwZjqP5UhXWeG4tqZ2OTsOTi2eLVrsHozx1ZveUrGPVkck33DP48qeWqFYQ6xFy/lqwz5o3CWbm2e66nqW1kXLIVdyb/bVAxzBndMoTEFSb1ZN71hmiD110Vqet9KFaRBXITFTZ2tvnN6u5ropHjk2yg33PM7+zz7MDfc8ziPHRls+5o37h3BkA2+FDhLRBXFTZ2Mq6vax2Q5F2yFTtLEdSUQXZIsWM7kiL47O8vK5LFPZYlvnFeTEZLYmS18KrbFCoVgc1uLf9M1X7fJVYVK6P71u13qfNcLUXdl7vmSTK9nkS659dEQXc90QVd0TAuq2Yb5jgWufLaXEKT9QIvryGPGtm+RBE4KBVJTzeuNNT7Xtle1GZ/MVZbtWH7S3XHMRn7h6d1MKjoWoPCIaXLAxSa5kk4q5Ntq2I/0BkgPJCFFTp/YnhdEAACAASURBVFC0ODmVAwnbel1/hnbOK8j2vq6aLH0ptMYKhWJxWIt/0wf2DHLbwUsYTMWYzpUYTMW47eAlfjU17LNGDKZiSIc5yaUA6cDGVIxk1EDXypUHT22hQSpm1G1Dd525lrpjBhdt6qY/EfGryIYu6E9EuHBTd0e/o2ZZF90WyajBhkTrZk+dLNvdcs1F7N3Wy62HnyOdLzGRrVVfpKI6f3bDPm7+ypMUWixFJSI6m3tiFX4Ls/kSRjkrPa8nTnfc1QKPzRbY2Z+oUUwspBy50vXYCoWiNdbq33QnTaKklGiaa/bkKSds6VYGbtw/xJ0Pv4SuzZlJOdKtRNc7jreNJmq38Z4f1fbUy3U91nTysFD5ZaPBNe0QtKkOI2rq3P6t51tOHACyRZtXzmXQNY2PH7iAx45P8PK5LLHyoFBRtkMtWDaWA31dnbUzXQw9tkKhWD5Ww9/0cqtB0kWbvi6Dc5m5ibb6EyaZos0t11zEvz57imNn52Z03rMpwS3XXFS33bdccxFAjaW1t3wlXY81mTx0akDkfINrWiVoU50pWlSbTI6ni0xkaqU4zaKVs9/7jo745bbR2Ty2Izk1lUcIdx1NuHaoQghSMXPB5+WhfB4UirXFSv6bXglqkGRE58x0HlOb82yYzFrs3hjlk/cerUgcAI6dzXDD3d9nZLpQt923XHORnyxUs5Kux5ob8xCP6Gzra35AZCMaDa5pB68bZDZvUW9izXYHVeqaQAKbUjFMXXD3o8f99p+ZzuNpiSTQn3B1wWem8x05L4VCoVhqgt3KQrg/vXvfUlEz66eYWx60k/b+gTsfxXK3uxOsmcqDEIKNqaj/Jt0JOlm2e+TYKEdfncSREsuW886s2SreFLAnJrP0J0yKluO3/+avPInEHa07kIwhBExni+QtyYujaXYNJPj0tXuWPaNd7hKkQqFYPXS6Wxlat6eeLbiOvNP5OU+HnphBumDVtZP22tnJdi8HayZ5GEgujkNkJ8pEXnktOA9KJ0hEdPIlm6CayJEwli6xrdcNzgN7Btm3o8/vfpnNlzg1lUcKQSKisbkntiLMSVZCCVKhUKweFqNbuVV7agFM562K+/p03qI73vgltpH9/2phSbothBDbhRDfFkI8L4R4TgjxifLyDUKI/xBCvFj+2beAY3SuwR3GK69t7okBggXO8O2Tihl+N0dV1YyJwExvwe6X0Zk8Xt1jIBldMSWzlVCCVCgUq4fF6lauvgc1YrzsMCkD/7zlZh3ZvS7a83lYaSzVmAcL+F0p5cXAW4CPCyFeC3wKeEhKeSHwUPn3NceJySwzuSIvn8tStB06ZQjm+6ZTG7zZku2bWgX1ywXbnQ3Tk27CyiiZrUVDGoVCsXg08mxoB+8+/dypaZ4dmea5U9PM5BoPYC/WMZEq2rLu9NoI0dF2LxdL0m0hpTwNnC7//6wQ4nlgK/Be4EB5tS8BjwC/vxRtWlKkbDirZr3Z0hohBGxMRZnJ15+4pbr0f2DPIDfc83hHS32dotMlSIVCsfbpqPqg6j7tdQE3pN4I90Yj3x25olQT7bLkagshxE7gcuAHwKZyYuElGCv+22zWrjq43qnpfMN9tjN4Uko4Ppap+7mhhZf+O13q6xQrtV0KhWJ9EOzqbRanTq+GIxp/thZY0uRBCJEE/gn4r1LKmRa2u0kI8YQQ4omxsbHFa+A8NGtXXb3eYs1p0Wi3liOZzZdqSv+dLvV1ipXarmZYKfGpUISh4rM55psEK4x6s2hL2fiztcCSqS2EECZu4vB3UsqvlxefFUJskVKeFkJsAUJf46WU9wD3AFxxxRXL9tU3a1ddvZ5nM9oJ5uvi8D4XAsZmC+iaqCn9r9SS2Upt13yslPhUKMJQ8dkcmiawHRk6C2Y76HX2t5D5i1YSS5I8CFcK8XngeSnl/wp8dBj4CHB7+ecDS9GedmlWV1y93kAiwmi6fefIIIYmKDXIRLxPdAF5y/U+v3LXBm6453Hln6BQKBR1SER0dwxZh9Krg3s3c/9Tp2sSkIN7NzfcbrX43SxVt8XbgA8DVwshnir/ezdu0vALQogXgV8o/75iaXaWubD16hHVBUaTiaju20uHfy6AqKER1V3RZiJicN2+rdx3dGTBM4MqFArFWuaS83rY0GW6NtO41dsNXe2bDt5x/T7ed9kWv9Kga4L3XbaFO67fV3ebTs3kvBQsldriCPX9kd6xFG3oBM3OMle93nh5voqIrvmBVLRsHKAvEeFcpgh1JD8bkxE298QZT+cZTxexpazoBtE1SEUNZgs2g6kI/Ymo367bDl7S0ZlBFQqFYq3i3bf7EpGK+3vYDMgeVw718djwZOhycBOIO65vvg2r6X695ua2WEyaHdRXvZ4jwdQq+7oMXSCAoYEkPTGD7phBzBD+OpqYSxwA+hNReuImuzcm0DUNUxN0mTp9cZOLt/Twiat3s7M/WdMu5Z+gUCgU81Pv/t6Ir978Vj9R8LhyqI+v3vzWttqwmu7Xa8aeeqlodlBfcL29n/n3mm4MR0IyavDVm95Ss209L4YLB1Oh63vcErJM+ScoFApFc4Td3+cb+NhuohDGarpfq8rDEnDj/iEcCZbj4Ein/NNdHkYnPQ+Uf4JCoVC0jzfA0ZNfegMg5xv42A6r6X6tkocl4JZrLuITV+8mbupYjluG+sTVuxvO2d4pz4PV7J+gUCgUy007Ax/bZTXdr4VcZY4VV1xxhXziiSeWuxmKlcmyC6jbjc+dn/rmIrRGsRi8fPu17W66auNTsS5oKT5V5UGhUCgUCkVLqORBoVAoFApFS6jkQaFQKBQKRUuo5EGhUCgUCkVLqORBoVAoFApFS6w6tYUQYgx4pc3NB4DxDjZntbHWz39cSvnO5WzAAuOzmtV6vVS7w1kp8ZlhdV6fTrNa43QxGACOtRKfqy55WAhCiCeklFcsdzuWi/V+/quN1Xq9VLtXNuvlPOdDfQ9ztPNdqG4LhUKhUCgULaGSB4VCoVAoFC2x3pKHe5a7AcvMej//1cZqvV6q3Sub9XKe86G+hzla/i7W1ZgHhUKhUCgUC2e9VR4UCoVCoVAsEJU8KBQKhUKhaAmVPCgUCoVCoWgJlTwoFAqFQqFoCZU8KBQKhUKhaAmVPCgUCoVCoWgJlTwoFAqFQqFoCZU8KBQKhUKhaAmVPCgUCoVCoWgJlTwoFAqFQqFoCZU8KBQKhUKhaAmVPCgUCoVCoWgJlTwoFAqFQqFoCZU8KBQKhUKhaAmVPCgUCoVCoWiJVZc8vPOd75SA+qf+hf1bdlR8qn8N/i07Kj7Vvwb/WmLVJQ/j4+PL3QSFoi4qPhUrGRWfik6x6pIHhUKhUCgUy4tKHhQKhUKhULSESh4UCoVCoVC0hEoeFAqFQqFQtISx3A1Q1OeuB1/g0JFhZvJWxXIhQABRQ2MgGUUC2/u6uHLXBh47PsGJySzb+7q4+apdHNgzyCPHRrn70eOcmMySjOikCxanp/PY5fG1hga2UzvcVtcEUcPNL/NF2x+SKwBdg56YwXTewnK8/Qg2pyKgaRXHVywtwevtXYdnTk5x6MgwmaJNIqJzXk+UF8ey2I5EE9AXN4hHTbb3dbG5O8JDx8bIFG0iumAgGWUqWyRbcrCd8EHZqahGT1e05rp7bXnu1DSZoo3jSFIxgxv3D3HLNRfN2+6w+KleLyzugYp1gueUiOihx5+vDc22T6FYDwgpW1ZoLCtXXHGFfOKJJ5a7GYvOXQ++wJ0Pv1T3Zh1kMBlB1wWjs0U2JiMMJKPkSjYlW3Ldvq3cd3QEUxdYtsOJiRzOIrd9Y9KkOx6hZEtuO3jJUt5gxVIdqB7LHZ+PHBvl1sPPYeqCuKmTK9mMzeRJF210TaAJKFoyVJfVHdUwdJ2JbAlNgCbwE8Nm6DIEW/q6/OsOcOvh50jnS0xkS/56mgAhBJ+4erf/AA9rd1j8VK93LlOoifvpXAkBdMdN4qbOqamcf06mLnAkOJKK48/XBu9c5mvfPKz7+Fyt7PzUN5ta7+Xbr13kliwqLcWn6rZYoRw6MozWxKUUwHimyEzOQhMwm7cQQtAVMTB1waEjw5i6+/t4uti6mLcNzmVK/vHvfvT4oh/PcSTj6cKiH2c1cPejx/3r7cVBumjjSDA0DU1odWNgpuAwlZt7yDeRt1aQtWTFdffaMlV+mItAPGvCjfFG7Q6Ln+r1wuI+XbCYzVv+OsFz0oRW/h4qjz9fG5ptn0KxXlDdFiuUTNHGaDK1cyQUbcd9q7TnXhXjpk6maLPD1AH3s6VIHryHTtzUOTmZXdRjZQoW59JFLMdhIBld1GOtBk5MZumNmxXLWkkCvHUXUpD0rrsEeuMmjqx8pZHSTR4yRbthu8Pip3q9sLi3HUmwohp2TtXHn68N3rnM1z6FYr2gKg8rlEREb/qmrwmI6BqOdH965Epu/26u5N4kI7q2JHVTr2KSK9ls6+talGNYtsPoTJ6zM3ksZ7E7YlYP2/u6/Ovt0UwFq3pdISorBa3gXXevLdXHF8J9oCciesN2h8VP9Xphca9rAkOb+z14Th7Vx5+vDc22T6FYL6jkYYVy4/6hppIHCQwkInTHDRwJqZiBlJJs0aJkS27cP0TJdn8fSEaWJHnoT5j+8b3Ba51kNl9iZCpHumDNv/I64+ardvnX24uDZEQvj19wcKRTNwa6o1rF23UrSQe4Yx6C191rS2/cdAfbBuLZkW6MN2p3WPxUrxcW98moQSpm+OsEz8mRTvl7qDz+fG1otn0KxXpBdVusULyBXM2oLQC29XVxwxvdUecnJ7NsC4wG37utl7sfPc7JySwXbUouutpCaBqDqVjHR6OXbIfxdIFcVblZMceBPYPcBv713tbXxaevfW2F2iIVM0LVFl1Rk21VyoS42bzaorcrWnPdvbYE1RbJaK3aIqzdYfFTvd7O/mRN3H/62tdCYJ3XbO5uSm0xXxuaaZ9CsV5QagvFqmA6V2IyU8SpE6+2I7lwU0qNZlesZFR8rlKU2qIWVXlYoYRp2f/12dMMn3MHaO0aSLBnc9J/m4rqGhsSJnnLoWg5mLpgYzJKpmgzOlvAkRJDE0gpKTnUvEHqAi4cTPKpd11c4w1RraVPRnSEEMwWrIrPnj45RTZQFejvMvjTD1y+oLezku0wNlsgXwqvNkgp+e6L4xw6MsyR37+67eOsNrzr88LZGUq2JFKuEJ0rK2p0TfCm83tBaJyYzJKKumX9k1NZciV3QGF1BaCRj8ENd3+fx4YnK9qga4K4KXjd1r6O+CFU+5EIIRhLF/x4vmhTd8N9BbcXwHi6QNGWDX0dFApFe6jKwwqkWm8+ni5wdqaAJtwbNkDJdrX6elmPXyp3HQjA0IWbHEhwcD9vZvyEBmxIRvj1t5zve0NUa+mjhsbIVB6Arb0xCpbDWLqIqQnyIaYAMUPwVx+6oq0EYr5qw9Mnprj70eMcOzMLwMu3X7su3uy8+ChaNucyRcCNhzCSEY3+ZJSRqbyrQgh85o4xdP0W9m7rretjcPd3XqpJHIL0xg2645EF+SEEY96yHUam8r5iQivHfH8iQsTQQ/cV3H42V2I07X4vhuZ6SoT5OiwD6yI+1yKq8lCLGjC5AqnWlM+Wxzw4EnRNQ9fmtPoSsANSOImr55flxEGUt2smKhwgXbAqvCGqtfTj6SK6EOiaYDxdZDbvfhaWOADkLdmyFr5oOZyaynEuXQhNHI6PpflvX3+WT37taT9xeMuuDS0dYzXjxcds3kKjUllQTbrouNdME37MeGNmPMnkoSPDDX0MGiUOADN5a8F+CMHtvBhzYM6fAvd86+2rYvtM0Y/3OX+LWl8HhULRPqrbYgUSpmWvVzioVziqWSzCFtZiO5KMPecN4R0/qKXXy08f7/f5RuU3q4WXUrrVhmyJsIrYmZk8X/zey/zHT876p/LaLd3cdNUQe7f1NnWMtYAXH0Xbca/FPBRtx69Y+YhKv4VmfRbCcOTC/RCCx/fPS1KR8BRtp+6+gtsHk2UvjMJ8HRQKRfuo5GEFsr2vi9HZPF0R9/JEdA3LDr/xec+O6mdtTa7QZO+UrgniukauZFccv2g7vpbeKpfIvd+DBj1hNKOFL1g2Y7Nu/3Y107kSf/+DV/nnp0b88vyODV18dP8Q+3f3I9o1JFilePHhxoWc148homtY1f1WstJvoTrmYM7H4MRkruH+NVHpeVBvP82cU1fE8M8LASJg8BQpx2XYvoLba2Lu78H7bsJ8HRQKRfuobosVSLWmPBVzb8SaANtxsJ05rb7AHfcgA79bjoMQ7sWV5e2ayR008AfR1dPSDyQj2FJiO5KBZIRUzP0sVscOM2aIhlp4KSUTmSKnpvI1iUO+ZPP3P3iVDx36Af/45ElKtqQ/GeF3f+EiPv+RK3j7hQPrLnGAufhIxQwcZEOTrGREc6+ZIyvexiVzycON+4ca+hhcOdTXsD3dMWPBfgjB7bwY02DOnwL3fOvtq2L7RMSP9zl/i1pfB4VC0T6q8rACqdabDw0k+eCbdlSoLfZsTlaoLbrMSrWFNxtiu2qLoDdEtZZ+98YEQgjSBavctvbUFvmSW20oVVUubEfyrR+f4UuPvcy58sC3RFTnhjfu4Jf3bSVmru83yGB8WPYMRVvSE6+vtjg5meXCwSRSSkamsmTLaotEpFJtUc/H4MCewbpqiy5TcPGWngX7IVTHvBdjntoioguGBpJ19xXcvmg5bO+L+2qLLlOpLRSKTqPUFoolx3EkE9kiM4EJi8CtQhx56RyHvnvcL5WbuuCXLtvKB9+8g56qvvQgQgiGBhLLXoZQ8alogIrPVYpSW9SiKg9LxCfvPcrhZ85gO9J/K5zMlip8G9516WbfS0EAZ6ZzvgSzHnFToz8R4exMgVKgmhDRoNihKR+SEQ1HCgq2g1buLC+V+9oT5txnhiaQjsSGutr6bNFifLZYU2p/+uQUf/3oMD85PQO4UfwLr93Eb7xtJ5u7Y3XbpmuCnrhJKlY/sVjJtOuJcNeDL4S6j7ZKo3G0MUOQiOhM5qyWZ9jsjrlVDa+C9eLoLEXLIVe0/JjWNcHBvZu54/p9Ndt75zebt9A0QUQXmLpGxNDYmIwipSRdtOt+Z618r82u2+61UijWIqrysAR88t6j3P/U6ZrlAvfNGvA1+IOpKI4jfZ36aiH4ENIAXa/U1lu2w0SmWDMfxfGxNIeODPP48Ql/2Vt2beDG/UPs2pisezxT1+jpMklFjeC4h1X1Zlft59GsJ8JdD77AnQ+/VNcqeqUggO64QVdEZ3y2WJHcBnnfZVsqEgjv/KSUFUmLJuYusBCCrb0xDF2r+c5a+V6bXbfdaxXylSwrq/H+uRJQlYda1IDJJeDwM2eA2pkK3b5p17fB07TP5i3GM6srcYDKt1eHSm39dK7EycnKiazOzuT57L8d42NfftJPHC7ekuKOX309f/K+19VNHGKmzqbuGNs3dNEdM1f1gMl2PREOHRluedKq5WImZ7k+IQ0a7P19eNQ7P6fsXeJIVy48ni6GfmetfK/NrtvutVIo1iqq22IJaOoNsbxK0XZaLhGvVASSdMHiXLrgLwuTXW7vi/PRtw/x9t311RPJqEF33FxTgyXb9VbIFG3qiFtWFF4Yh/pMBKj++/DOzwr7OwgoRTyJcPV31sr32uy6C/HBUCjWIip5WAJ0TcyfQJTr/hFdw3bsVZ9AeCXnePlhny/ZfP3oCF/9z1fJFFxFRn8ywkeu3Mm7Lt0c+nDRNeEnDaa+Cp6WLdLIW6ERiYhbNl/peFc01GciQPW1985PiBATtLL3g+f7ALXfWSvfa7PrtnutFIq1ytq7I69ADu7dDJT19YGboWDOt8HTtKdiBgOJyLK0cyGIqv/3tPXX7dvKN585zYe/8EN3SujC3JTIf/ubb+I9e7fUPDwihsZAKsqODV30J6NrMnGAWj+PZj0Rbtw/tGqSy+644fqENGiw9/fhUe/8tLJ3iSbAlq7PSNh31sr32uy67V4rhWKtoioPS4A7GKyx2uKiTUlfbXFyMsv2vviqUlvkLRszoLaI6Bpv2dXPt18Y59UJ9xxNXfDey87j1958fqjssiti0BM3ia8TJ8Bqb4NmPRE8BctqUluU7ObVFsHza6S2yBRtBlOxmu+sle+12XXbvVYKxVplydQWQogvAO8BRqWUl5aXfQb4GDBWXu0PpJT/2mg/arTwysMb1+B1zTx7cpq7Hz3elOxSE4JkzKA7ZvrTSi+AZR9GqOJT0QAVn6sUpbaoZSkrD18E/hz4ctXyO6SUn1vCdqwIGmnG633W7ja3f+t5XhrL+HJQARiaoCdukC06FGynri9Do2NatsM3nj7Fl77/CqdncvTGI2gCni/PdAnw5qEN3Pj2IS6oUk8YmkZ33CAVMxsOplO4NBMTyYhe4cpo6oKLNnWHxsmzI5Pkyk6TMUOvcCd1pIMm3Lf8CwdTS/aG3aqPQvX6V+7a4PukKB8GhWJxWVKfByHETuBfqioP6VaSh7WQOTfSjAOhn123byv3HR1peZsvP/4Kk5kidoPLbGqAqPRlmK+d+3b28a1nTvO/H3oRkGQKdkUJ/eItKW56+y5ev71ytsuoqdMTN0mUH3QdZtmzkMWIz3rXIRgTlu0wMpX3ZyP1pJH9iQgRQ6+Ik5lckalcbXeHwBtP4P7UhWAgFcHU9Vb9DDp2jvWOW73+eLrAWLrIYCpCfyLarg/DYrMm43M9oCoPtayEkWi/LYR4RgjxBSFE4xl41giNNOP1Pjt0ZLitbdKF+furbVnpy9ConYYGdz38IuOzBf728VdI5y3OTBf8xMHQBDs3dPHnN1zuJw5CuKqJ83rjbO2Nk6w0dlLMQzMxMZ4uogvh+yAYmoaGYDZv1cSJd62qL4GkcvyDpglmctaS+Bm06qNQvf5s3kITrq+E8mFQKBaf5U4e/hK4ALgMOA38adhKQoibhBBPCCGeGBsbC1tlVXFiMutLGD08zXi9zzJFu61tvK6KRnjFJ024Gvuwdkopscp6/ZHJLPf+8FWeOzXDbMHyJ2IaTEXZ2R8nb9kIIdA1QW9XhO19cQa7Y2vKoyHIYsdnMzFRtN2ZVD0fBLdd7vLqOGmUTHqxIGXt9otJo7+JZtYv2g6aqJweXvkwuKy1+6diZbCsyYOU8qyU0pZSOsBfA2+qs949UsorpJRXbNy4cWkbuQhs7+uq0el7mvF6n4Vp+5vZRtfEvLUo7w3Uka7GvrqdjiMp2W7yMJ4uMpEtcc93h/3xE/2JCEP9XfTGTQqWZEtPnP6kK7XckIhgrFGppcdix2czMRHRNffBH7Bw9rwQquOk0RATLxY8j4Xg9otJo7+JZtaP6BpOwPthvu3XE2vt/qlYGSzrXV0IsSXw6/uAHy9XW5aSRprxep/duH+orW2SUWNeK2NdzPky3Lh/yF9+4/4h8iWH6VyRmXyR4XNZJrMlSrbE1AVvu6CfwVSUroiOEJC3bCTwiXdcSE98dVtHrySaiYmBZARbSt8HwXIcHCSpmFETJ90xd5x09XAnQWWnp+NIuuPGkvgZtOqjUL1+KmbgSNdXQvkwKBSLz5KpLYQQXwUOAANCiJPAHwIHhBCX4VZaXwZuXqr2LCfzacbrfeZp5lvd5vZvPc/PxjJYjdQWZqXaYjpX4oLBJL+4dwt/+/grfneGAN5x8SC/+bYhNvfE+OHwBP/4xEnOzuTYviGhRrgvAo3iJRgTuzcmKtQWEV0wNJAMjZMfj0ySraO2kNJBlNUWO/uTS3JNW/VRqF5/aCDJB9+0wfdJUT4MCsXiombVVFRQsGzG00V+emaGQ98d5vs/O+d/9qahDXxs/xAXDCYRQpCKuaZOK8gBctlLHSo+FQ1Q8blKUWqLWpTD5BLhadJfHJ31Nfgbk1EyRZvRWXfiqI3JCMmoQbpokyuUfGe/ahdAQxM45aRvITbFwf3q5QX1JJ0a8MrYLP/3fU9jO9J3+hNCMFuwfJ39t358huPjGQCG+rv41Lsubvrtr1Wd/1rlk/fOuZF6mJrwHUR1TXDhxi5OTRdIF1x1QdwU9MZMJnIWBau+b0dw357D45npPI8NT7bcTm97oKa99djWE2WmYJMp2kQNjQ1xg5zlULJly74Sdz34gmt5XnTHf7xjz0bOzBQXFD/teKkoFOsRVXlYAjxNesm2GZ8tug9pxx0W705f7a5nOe5DOmpAiAx/xWDqArtsTy2EYGtvjKLtcHamABIM3U1gHQm9XSafu+71895kW9X512HFvtmNTOXQhcDUBVFTJ1K2Wq7mk/ce5f6nTi+oDfV8Ozqx705halRYr5u6AEnTvhJ3PfgCdz78kjvfhYCS7U7EtqHL5LzeeFvx047/ylqJT0VjVOWhlhVTb17L+Pr6nOvTb2juyHgH92o5cq6CIFnZiQO4HgJSuG3WNcF4ushMuUoiBeia5v4TgnTBakpr36rOf7Vhlwf3TedKjM7kOTmZ5eXxDCNTOcbTBWbyJfIlmweebu3hLqj0axDU9+04/MwZdx0x92+5sGXlncrQtJZ8JQ4dGUYT3nnO3camcqW246cd/5W1Ep8KRauobosl4MRklt64SbHskwCV3RDB4s9qqQN5bfa8AKqXe5/ZjmxKa+99R0HWik7/p2dmKZRsEtFKV01HSgolm0JActhyN1R1AiDq+3Y0062wVHiyUqripVlfiUzRJli48c45eIqtxk+jGJSwZuNToWgHlTwsAdv7uhidzRPRNSynXO6n0swHysY8rI4EwjckCmjrS7Zd8TYry5WJZrT23nfUFZkLybWg05dS8ot/fsRVPxgag6lo+V+Mwe4om1JRNqaiDHbHGExF0USLCYT3EA78Xs+3Q9fEikkghKiVirbiK+F5XHgyZG9/QVlyq/EzXwyuxfhUKNpFJQ9LwM1X7eLWw8/RHTcYny3iiHICUe660AM3ewHEVvCYB4HrISDkXGVhc3eUou243iXO+QAAIABJREFUpj0SbMetRDgSeqNmU1p77zvKFq2KPuXVrtM/lylStNzvo2g5nJzMcXIyV3d9Uxc4jSYiqUL6/5n7XSfct+Pg3s3c/9Tpmof2cqALKAXaYTkOSOhOmE1d9xv3D3Hnwy9hOU5FwtAbN5FSthU/88XgWoxPhaJdVPKwBAQ16SV71tfgD1SpLTZ3u2qLTNEmuwRqiyBG2SHIcsI/NzXBplTE9QKwJZG4xkAigiiPa9jZn+SGN+6oUFvsHmhebdGqzn+10J+I8NStv8DRV6YYmcoyNltg1Ps3k2d0tsB4uuBfx1KTiUPM0Cg5EtuRCCCiQyJikCnZFC1JQte44U07+NCVO5nNlzB1jT/9wOUAK0Zt0RVx1RZ+TLXgK+ENAvXUFsmo4ast2o2fdv1XFIr1iFJbrFGklLw4mubOB1/gWz8+4z+cXrMpxW8duIB3XDy4FieoWvaTqRefr57Lum/XIdiOZDxdYHTGTSrGZvOcnXV/d5ONfMWMpfMRN3UGu93ukY2pKJvKXSSDqShbeuKc1xsnETWI6Bqm4Q7gNXWx1mJhJbLsX7C6f7aHUlvU0nTlQQhxVaPPpZSPtnLg1Uq7Wu9Hjo1y+7ee56WxDLYjMXTBplSUZNRgZCpHtuT4b24C901faALLkUR1DUfaVD8/oobGxw9cwC3XXMQjx0b5H/c/w8h0IXTMhFe9+OnZWf7rPzwFQEQTSKBUHoextTvKH79vb835hJ0zoDTvLRA1NbTA1A1SukmDI90KwKbuGJ/91vM8dXImdPuIDt2xORdIpzzi0JESKSsrU7mSzSvnsrxyrv5gvpipcf6GBIPdURxHMjyeYSJTpGA5/jCKZFSnO25yLl0gb80dQdcEXabGpVt7O3rdG8VZ0B9lMBVDSslYukDJdl0yhRAVPhHedio+FYrFoenKgxDiGyGLJfB6YJuUckmmTFzOzLldL4JHjo3ye/c9zWSmWNeEqR7zDaAUwC9dtoUHnx9ltmA3WLM5UlGdP7thX4UxTvU5z+RKSKAnbi5E874YrMo3O9uRfPCe7/ODl6eaWl/DHSvj/x4YfLiUdcSeuE4yGuEP3rWHt79mI3p5JlVDE2hCoM03qUqAsDibzpVcK3Vd+P4ojpRIpzxAsrytKxkGDcFAKoJlSxWfdVCVh/ZQlYdamq48SCl/seIoQuwH/jvuVNq/3cpBVytBrTdAV8QgW3R9DBrdlO5+9Djpwtz4haCcbj7mnU4b+OenTi/4oeGNVs8U7YrzCTvnkckcCNjSE/eXNfM9KMLRNdF04gDUZJTVlYf5MHXhj3nojplkChb5eoNdGjCds8kW8vy3+5/l516zkU2pmKscSUXL3SQxIobmJxKaAL0sNdKEQBdekgH/3yM/Q9fwp22PmzojUzkoK3a0ckKSL9kVfz9BpZJW9lKxy39oKj4VisWj5QGTQoh3AJ/GvV/9iZTyPzreqhVKu14EJyaz2IFJqTpNJ982HUnF+YSds+U4Nf3jSvO+dNRLPJuV+RqahsDGciQxU2NTKsFPzsy21ZaSIynlLb4RYm4lgP5kxJWl+gnFnEx1MBX1Z199ZSJDd8ygFEhiLNtByrLzquY6ZtaoSyr8HaTb7VJWAjlS+n9vMUNT8alQdJBWxjxci1tpmAb+u5Tye4vWqhVKu14E2/u6GE8XsFrts1gGNEHF+YSds6FpNVmQ0rwvHdUeCZ7nRismIRJBMqqzY0OC0dm83/XRaoT2lidG27MlVR7wmWcyWyofA8bTRcbTRX5SxzjT877IFGzSeYuooWHqGoYufD8UI+CPUk3w1B0Jpq75lYdgIpIr2fQnogyPZ3xXTq28Q89mXRMgKP8UVT8RCM3dRlD+Keb2owXWVyjWA61UHr4BnATOAb9f/UcipTzYwXatSNr1Irj5ql383n1PU7LKYx5auEM38zzoT3il5/aTE+9hlIjoFecTds6pmIEEpXnvIFcO9TUllywraiuXibllDo3jRaPSA2Lvtl5uPfwcvXGTifJDv1n6ugySUYNb3/Nartw9QNFyKNkOs/kSZ6bznJnJu2qRsorkbPn3s7N58qVK7wuPoCOmh+V4gzjnzsz7uwgarUlHkowbvtw4V7KJmRr5koPlSK5/43aklH71wl6EESIxU+e83njH96tQrDRaSR5+ftFasUpo14vgwJ5BPnfd67n9W8/zs7EMVotqi4gmsB2HYlW3tADefelm7rzhco68OF5XbWEI6IoazOatis+aUVuEnfOnr30ttPE9KOrz1Zvfyg13f79uAhE3NQaSUXIlm6LlIKWDEFqF0mBjMoqUklcmsuRKlcES1d1rbUu3iyk446Z3fZ87NU2maPvjIRIRnZ64yXi6ULE/T22xZ3NP5XWPuj82dce4YGOSou2UEwrpJxYl20FKSbpglb0u3GrF6GyB50/N8OJomlzJrvAvkVU/q/8fysmvJijZ8PptvfR2mTxzcpqJTJEtPXF+7U07eNOuDa1cEoVC0YCWfR6EEDFgN+7f78+klPnFaFg91tNo4VzR5tWJDF/8/sv809ER36nwvN4YN719F7/yhu0kYsrnK8Cy14zXU3y2g5TSTyoK5YSiaDk1BlO2IzmXrjTUWoj3hTu2ozygsztaMbhzU7f7/2GznLbKPJUHFZ+rFKW2qKWVMQ8G8CfAbwKv4FZAtwkh/gZ3DERrNc8lpF1vhoVs6/k6DJe19o7jUGp9QHsop6byfOYbP+Ez3/hJZ3Y4D0LA1p4Yf/xLr+OBp07ywNOn/TdDXbjTbl+0qVtVH9rgk/cebdqdcaXTzrws9bYxy89xr1KyKRXh5Ylc046q1fvNlxxemcjyysTCBk32xnSiEYMt3XGuf+N2Vc1QrFtaSbX/J7ABGJJSvkFKeTlwAdALfG4xGtcJPP346Gye3rjJ6GyeWw8/xyPHRhdtW8/X4aWxDFK6I8A7lTgsB1LCyak8H/3Sf3L/U6crbuC2hHOZEsPj6aa/V4XLJ+89yv1PnV4TiQO0p/qpt03Jcf9Rlg8fP9d84tBuW5phKm8zNlvghdFZ/uhff8KfPfQijx8/x/B4hkxhhU5Io1AsAq3UvN8DXCQD/RxSyhkhxG8Bx4BPdLpxnaBdb4aFbOv5OuieUY69cPOmlUAjschs3mJzj6G09C1w+JkzQPgMkwqXlZhzOxKy5YGd9z91ivufOuV/lowa7NqY4IGPv00pLxRrmlYqD1KGDJCQUtqs4FmkT0xmiZuV5pfNehK0u63n67Ce7h1F21FeDy2yVioO65FUzCBuaujCnajOI12wmMmVVOKgWPO0Unn4iRDi16WUXw4uFEJ8CLfysCJp15thIdt6vg6eje56IKJryuuhRXRNqARilbKlO+Z7R3zuA3uZzBQZnS0wmS3R1xVZ7uYpFItOK5WHjwMfF0I8IoT4UyHE54QQ3wFuAX5rcZq3cG6+ahclW5ItWkjp/mzWk6DdbW++ahfJqIEtJXadmRRXI3qDRCgVM5TXQ4t401mrLov66GIFSBSqSJiCXMn2vSM0IehPRrl4SzdX7xnk2r1blruJCsWi03TyIKUckVK+GVcW/jLwKnCblPJNUsqRRWrfgjmwZ5DbDl7CYCrGdK7EYCrW9AQ57W7r+TpcMOC+hUd0gbHS7oAtIARs643x+Y+8kfddtoXgfEe6gIGEydBAciVMPLSquOP6fbzvsi3oLUwgtZJp5yzqbRPRBVHdtXBMxQz2bEq09D11RXS29URDb3AC2vp7FLhqi1Q8Qn8iyieuvlCpLRTrllZm1Wz4VyKlnOhIi+ZhNeiUi5bDTL5EOm/hSNcg54GnRvi7H7zqa9N74yYfvvJ83rN3Cz3xCP3JCKa+cJ35OmfZn8KrIT4VzRH0pChaDkXboVDypkMPR/k8rE2Uz0MtrYx5eJJwB33v93Vfr84ULGbyJXLlkdi2I3no2Ch/871hzs4UKtadypX4s4df4s8efglw55TQBNiO+2V2mTr/58+5X+lffudn5EoOAtjWF+eK83t56NhYhWOk5wh4yXk9XLlrA48dn+DEZBYBjKcLFG1JRBcMJKNI8D0rwFWHvDg6S7ZgU7RtdE1j10CC33/nHlVJWEI8T5Fqp8cuU+PSrb2hPhqNfEiCnyUjOkIIxtKFskOl60xp6oKNyShCCE5OZhs6nSYiOu/Ys5EzM8WGvifB4wbjLxGpdLb01ntxdJai5WDqoq5fSDPnGbYfoG2flnrbeYmEa3Rlh5pcKRRrnVYqD+dLKV9Z5PbMy0rLnB1HMpt3k4aS7Y5vkFLyg+EJDn13mOPjGX9dUxOUOnSTqWeuk4xo5CzJYCqCbUtG00XA7Z/yRl8MJiOk4ibTuVJ54iHB6EzBl2Lq5Ql++rpM/ud1r19NCcSqfbPzPEXS+VLoHBN9XQapWKSia8jbxtRFxRwjtx28BMD/zLIdRqby+H/r5STV6wXwJpVqFJneeBdbum3Z2ttVcbywNs3mSn78GZobU46ET1y9259To2TbjM8W/SvXn4gQMfSWzzNsP5bjzqrZHTdrtmsU042OV287y3YdMx0pScXM0HVYxfG53lGVh1paqZPf32JD1jRFy2E8XeDViSznMgU/cXj+9Ay/87Wn+YP7f+wnDr1xk83dUawWEofQyY8CC8P2JIB00UETMJOzGM8UKyZM8tYZzxTpihikC5ab+OQsnMAxJW4lYzbvelooFh/PU2SqnNBVM52zMHVRcT2CPiRCuD+9dYKfjaeL6OUHt0PlAE0p508cwE0avHWmc1bN8cLaVBF/0p2NVRNw6Miwv95MzkLThPsZbsy1c55h+/HiO2y7Zq5FK9sZukYiajRKHBSKNUUr3RbLnjWvBPIlm+lcqcZN7tWJLF84MsyjL477y96wo5ePXbWLPzz8HKmYwZmqrovFQhOu70J5ZuIavBzGdiRSSmwpKp4eUrqJimU7yrdhiTgxmaU3bja8ZtU+Gt42Qbx1JPifFW0HXbgTY4lAEtDqFNxe0hHMgRu1KXgu3raacB0jvfWKtuMPhBQi3C+kmfMM2497XBm6XSMaHU+hULi0kjxsFULcVe9DKeUtHWjPiiVbtJjKlsiXKt0iz6ULfPmxV/jms3O2zbsHk3zs7UO8cac7xnRrb5ypbBFN0JLFbrs40vVdsB07VAbolat1TYAU6JrAcmz/SeI5HhqapnwblgjPU0Sr4zapiVqPkfl8SLzPIrqGZbslfMrSRy9B9K55M2HpxUVQ9NCoTcFz8apmjnSnfffWi+ia271QXjfML6SZ8wzbjy0lyMpUrFmflna9YRSK9UIr3RY53EGT9f6tORxHMp0rcWIiy5npfEXikC5YfP7IMB/+/A/5xjNu4rClJ8Z/f/fF/NWH9vHGnRvQhGAgFeWWqy/EcqC7hRkww6YcDj5Uwt5OJe6YB0dCd9xgIBHx96MF1hlIRMgWLZJRg1TMoDtuoAWOKXCrEqmYoXwblgjPU6Q3boY+yHvitT4ajXxIgp8NJCPYUrqDcqns/hLlgbrzlRWDfgs9caOu70nFcYPxJ8By3GrYjfuH/PW64waOI93PkKF+Ic2cZ9h+vPhux6elXW8YhWK90Erl4ZyU8kuL1pIVRMGymclZZApWjSyraDkcfvoUX3n8lVDZpSe3TEQN+hMRDF1z/SJw+1J/PDJJuuDUPCAWQ21xcjLL9r64P9o9XlZbAAymYnz62tdCuV0lWyq1xTISjJEwtcWezT01SoHgNicns2yrUgUEP9u9MRGqtvAUOK2qLcKOV92mouVUxF+XWam28NYr2a5KIqILhgaSbZ9n2H5osF0z16KV7RSK9UQraovHpZRvaftAQnwBd3KtUSnlpeVlG4B/AHbiGk99QEo52Wg/izVaWEpJpmgzk6vtmgBwpOSh50f5QkB2GTM1PvCG7Xzgjdv8EqehafQnIySireRlig6x7ONy1Gh2RQNUfK5SlNqilqafcGGJgxDiAuAG4HovIWjAF4E/B4JzY3wKeEhKebsQ4lPl33+/2TZ1Ast2mMlbpPMWVoiVtJSSH748wV9/d5jjY656QtcE73ndFj585flsSMz52CdjBv2JaEMnvLsefIFDR4bJFO0K3XuYJn90Nk/JlkQMjQsHU35F4cXRWWZzJQr23Bvitr44f/TeSzmwZ5BHjo3y6Qd+zMnJnG/MQbkvWNcEB/du5o7r9/ltaqRpV6xsmvV5qPZbaMavIbiPZrwYGrXpgadOcviZM341JRiDzZ7DfL4Sjdq40GMoFIpKmq48+BsIsQX4VeCDwF7g/wW+LqV8toltdwL/Eqg8/BQ4IKU8Xd7vI1LK1zTaR6cy54JlM50tkSnaNSOyPY6dmeGeR4d56sSUv+zARRv56P4htvbNuciZulttCA6wCuOuB1/gzodf8rsonLJM7uDezTz56nSFJt9xJEIDTbhKiGRMZyZv0xMzmMyW6vaLf/RtQ3z+e8NM56yQNeZ432VbuOP6fW1p2lcw6+rNrlmfh2q/BS/uNnSZnNcbr3vNvf0348XQqE2np/P+FNZB3nfZFt572bamzqFebDbTxkb7aeYYHWRdxedaQlUeamm68iCE+BhulWEb8DXgRuABKeX/01LzKtkkpTwNUE4gFv1plS1aTOfmXCDDODGR5Qvfe5nvvDDmL7t8Ry83vX0Xr9mc8pcJIeiOGfR1RdCa8N0/dGQYTbhdGzA3iOzwM2fY2d9FV8Tg+FgaXQhsIZEOREwNR0qmcxa65voA1Ev3ZnIWh44MM5u3KqoNQbzR6IefOcMd11dq2gG6Iu4As7sfPb4ak4d1RaNrB/ifDY9nfFOxoNpnKldia19X3Wvu7f9c2vVQ0ITwTdE29xihMRLeJvdvrcKnpByDZ2aKTZ1D9WfecZtpY6P9NHMMhUJRSysd838BPAZ8UEr5BIAQYkk8WYUQNwE3AezYsaPl7R1HMluwmMnNuUCGMZEp8uXHXuFfnjk1J7vcmORjVw1xxfl9iMDdL2bq9CcjRA296XZkijZGlb5FE1CyJXHT3Y+vyQ8qK8pVClNAqcE3LsvH8LsqGuANilOa9oWz0Phsl2Z9HsL8Frzl1duF7b8ZL4ZGbaqH7cimz6FeO5tpY6P9NHOM1c5yxadibdNK8nAe8CvA/xJCbMKtPizUTu2sEGJLoNtiNGwlKeU9wD3glt2a3XnJdpjJlZjN16omgmQKFv/wxAnue+IkectNLrb0xPgvb9vJ1XsG3a6DMpoQ9CUi9DR5gwySiLhl0WCRwimPQ8iV7EpNflCDL+e6ORp5RYjyMWbzjbssAP9GqzTtC6fd+Fwozfo8hPktzOfXENx/M14MjdpUD10TTZ9DvXY228aFHGO1s1zxqVjbtDIl97iU8i+llFcB7wCmgVEhxPNCiD9p8/iHgY+U//8jwANt7qeCfMnm7EyeExNZpnOluolD0XL4p6Mn+dDnf8hXHn+VvOXQEzf57Z+/gL/5jTdyzcWbKhKHrojBtr54W4kDuPp2R3p6d8fXvR/cu7lGky8kaFp5XUfSEzdwpPuWVK+q0B03uHH/EN1xA0m42ZC37ODezYDStK9mmvZ5qPJb8OiNmw2veSteDI3a1BVxq2qeV0kwBps9h/l8JRq1caHHUCgUtbSlJ5RSngQ+B3xOCHER7liIhgghvgocAAaEECeBPwRuB74mhPgo8CpuZaMtpJSkC+54hqJVv2sCXNnlw8dG+cKRlzkzkwcgZmj8yhXb+MAV22tklrom6E9GSS5Qfunp2xupLSo0+bN5dzbMFtUWe7f1Nq22UJr21Uuz/gfVfgvJ6Px+DdX7n8+LoVGbPn3taxuqLZr1qpjPV6JRGxdyDIVCUUsrPg8fKq//t1XLPwZkpJR/vwjtq6F6tLAntZzNl+adFldKyROvTPLXjw7z0lgacN/Ert27hY9cubNCdumRjBr0JxvLLxUrhmW/SGo0u6IBKj5XKUptUUsrr9K/C1wVsvxe4BFgSZIHj3oTVNXjp2dmuee7x/nRq3Oyy5+7aCMf3b8ztH/T0DQGUvPLL1ulns+DR7VHQ9zUeOclm3xNfirqWgOPpQsVHhDe21K1Zn1zd4SHjo3VPV6rKE382mC+OFwsgvGDlExkShRsp6YN3novnJ0JjfN6+5zPC6JVXwvPibMZfwuFYj3RypNRl1LOVi+UUs4KIZZsHlpHSk5OZuftmvA4OZnlC0de5pGA7PKy7b3cdNUQezZ3h26Tipn0J5qTX7ZC0OfB0NyBWXc+/BKA33XxiX/4UYVHQ67kcP9Tp9nQZZKKGbw4mkZK6U+bnSvavHwuza2Hn+O6k1Pcd3QEUxf0xk2ePz3NY8ctdA2M8qDM4PFaJajh742bjM7mufXwc9wG6oa6ipgvDheLYPwUShZj6RIAZlUb9m7r5dbDz1G0bN8CPhjnwXhrJiabjdugZ8R0toSDxHbc6qSuCYbHa4+vUKxXWpkYyxRCJKoXCiFSQG29f5GwHNlU4jCRKXLngy/yX774hJ84XLAxwWff/zr+9Ff2hiYOpq5xXm+cjaloxxMHqPR50IRW/ukuB7ffdSbnejQIUamLn8qVGE8X0TWBI+dmvdQ0wUzOwtQFh44M+5p1IYR/43VH1tcer1WCGn4h3J+mLny9vGJ1MF8cLhbB+DmXcRMHAdheLJfb4K03m7fQEDVxHoy3ZmKy2bj11pvJuZ4RwR5dDbc9Kt4VCpdWKg+fB+4TQvyWlPJl8B0j/6L82YogU7D4xydO8rUnT5AvuUnG5m5XdvmOiytllx5CuG8kvV1mhZdDx9tWx+chUzbROVHWnYe1wJH4WvbgyI6gpj1TtNlh6hXbQKXqIni8VlGeEGuD+eJwsQjGT3B4khefXhsqvBtEY3+JZmKy2bit9oyQgb+f+fwtFIr1RitzW3xOCJEGviOESJYXp4HbpZR/uSita4GS7fCNp0/zlcdfYSrnvtV0xww+9JbzOfj684hU3y3LRE2dgRbNntqlns9Doixl297XxchkLnRbTTCnZQ8sD2ravf174zQ8TwhR53itojwh1gbzxeFiEYyfoF+JF59eGyq8G+zG/hLNxGSzcVvPM6IZfwuFYr3RSrcFUsq/klKeD5wP7JRSnr/ciYM32+Vv/M1/8ufffompXImYofFrb97BV258M9e9YVto4qAJQX8iytbe+JIkDlDf5+HG/UOAq1kPejQEKwa9cdP1gHAkWrlLw/OA6I67mvYb9w9VaNa7Y+7N0nWorD1eqyhN/NpgvjhcLILx059wKwES0L1YLrfBWy8VM3CQNXEe5vPQjBfEfHFb7RlRkXTP42+hUKw3Wpnb4neqFkkhxDhwREq5uJ2lIfiyy+8O89JoQHb5ui38+pXn05+M1t22K2IwkIxg6C3lTgumkc8DuIOw7vzVy+uqLU5OZrlwMImU0tfsRwyNnf1zmva923p9zfrFW3o6qrZQnhBrg/nicLEIxk/RctjWq8+pLczKNnjrWfZMaJyH7bMZL4hWfS08tcV8/hYKxXqjFZ+HPwxZvAH4P4DPSCnv7WTD6rH38n3ys1/+Jn/93eMcDcgur7pwgI/uH2L7hvolRUNzZ7+sNoFSrBmUjl6xklHxuUpRPg+1tDLmIXT2TCHEBuBBXL+HRefUVI7f+ruj/u+X/f/t3XmQpHV9x/H3Z3pmdmZn7wuRRXdX0ZVVECQooNSKmsJAVqlAyYZ45PCoGEWiRZQYYrY0kqp4YGmZUHiQKqOmUI7SilFRggfiAcghhHOFBXQ5996dnZlv/nie3u3p7e7pZ2a6n366P6+qrenn2F//nu7f75nfPM/z/f6OXMjbX7WGFx1eO+yyrFXhl1l85vv38G83PMDu0XEkOGLBHD561jEAXPLfd3Hf4zspz9tVnrY7EKU+sWbZCH93+tpJuRwaxcBf8LWba2b0c56GYmrH91brPYCm8y00Kue2Lc9MeaUjay6Gcp3KauViaFRmo+MtrytndXV/MZus6SsPDQuRbomI42ahPlOac/hRcfhbP82a5SO8/VWrOXHVkoYREgOlPpbPn8PQQHuea6jnM9+/h09fd+8hk1oN9YvBUh87941TLwC1pCQiZPHcAd78iudy5c2PMDo2zpO7RpMdApbNH2SgVGLThnVcc+sWrrr1sUPKOWn1Yh7Zto+BkhgeSB6a2z8ebNqwrltOiF35l11lnoJWfW+13mN7Ov17f5/qtrVayZiqy9m6fS+7Rscp9enAg5ITAeef9vxJSaGaOcbyfuX2PxFJLoaSoK9PLB0ZZLA/qRtQt8xa28rHu3B4gOGBEk/u2sfWHaMsnzfIsnlzZuNz78r22Qt85eFQM77pL+k04OmZltOsgb4+PvT6tVz25pfx8tVL6w4cJLFo7iArFw/nPnCA5P5yeWrkyhwOe8eCnek02vWUE0Lt2Dt2IJdDoxj4a2/7HVS8T/m9bnzwaedpKKB25Neo9R479o6xc99YU/kWGpWza3SciWicVyJrLoZynSLtU8GhuRgaldnoeA/kSdkzRp9gx94x9xezKlkemLwdDvkdtwR4FHjLbFaqkdXLR3jd0Yc13Ked4ZfNOhBDX2OsM8WUHAfCxcbGJ9g/GjxnoNQwBr7RHB/DVQMpx613vnbk16j1HmMTE0hinJgy30Kjcmo1x+q8EtPKxaDGuRgC6pZZa1v5eMtGxyfoS8tsVCezXpTlycEzq5YDeDIids1ifabUKIeTJJbMHWTh3LZly27ayGApyfhYIwtUXxpHXu9XfjnOvL+vj8H+JNa8UQz8o9v21h1AVOaBKC87br2ztSO/Rq336O/rA0FJmjLfQqNyKnM6lFXnlZhWLobxqXMxNCqz3vGWDZb6GB2fYLAiKsv9xSzR9G2LiPhtRPwWWACcCLwcaG1geAZDAyWOWDTckQMHSOLXkwcgJ+dwGOoX8wZLDW82CRifSOLMy7kcGsXAbzjmWVDxPuX3Omn1YudpKKB25Neo9R7zh/qZN6dhgJeKAAAP1ElEQVS/qXwLjcoZGSzRp8Z5JbLmYijXSTo4Hq/OxdCozEbHeyBPynA/EwHzh/rdX8yqZLltsRC4BjgSuI2kv75E0kPAGyJie2uq2FifxOKRQRYOd+agoaz8YFjWaAsQfVXRFuVcDvVi4JOHuRpHWzhPQ3G0I79Grff4hzOOBprLtzBVOVNFW0wnF0O5TmW1cjE0KrPR8W55ejerls5j4x8k0RbuL2aTZcnz8BlgFLgwIibSdX3AJcBwRLynZbWscMxxx8fV370ByC/Zk3UsP81unczts6AcbXGoLM88vBY4pjxwAIiICUkXAbdnedOZKvWJJSODzB/q7KsNlZqJYZ9qn+rt1THojkk3ONhO7t2aZEmslf+g22XJBWFm2WX5k300IsaqV6br9s1elRorSRyxaLhwA4eLr72TrTv2smh4gK079nLxtXdy/d1bm96nevvmJ3dy6Q/u48EndtZcrvUe1v3K7WTzkzvZtnt/kr9g7xgPPrGzZ9pD+TN48ImdbN87xq7RseTnvrGe+yzMWiXL4GFI0nGSjq/69zKg/kQSs6zUp8Ldpmgmhn2qfaq3V8egOybd4GA72b5njL6+NDdDVf6DbpclF4SZTU+W2xa/Az7ZYJvV0UwM+1T7VG+vjkF3TLpBVR6EvuZyM3SbLLkgzGx6ssxtsb6F9ehqzcSwT7VP9fbqGHTHpBtU5UGYaC43Q7fJmgvCzLJr+vq/pAsrXp9Tte2fZ7NS3aaZGPap9qneXh2D7ph0g4PtZMFwPxMTaW6GqvwH3S5LLggzm54sDw+cW/H6Q1XbTp+FunSt9WtXsGnDOlbMH2Lbnv2smD90yOQ6U+1TvX3V0nmcf9rzWb1sXs3lWu9h3a/cTlYtncfCuckETwuH+lm9bF7PtIfyZ7B62TwWDvUzMtjPgqF+Rub099xnYdYqWZ55UJ3XtZatysHkTdPfp9b291btU71svaeZttbt/BlYp2s2dwR0Zv6ILIOHqPO61rLRXG6HZvbPWo5ZEbSyXU+VE8V9yGxmsgwejpW0neQqw3D6mnR5aNZrVnDlWPOBkiblXdgENU9a9fY/e8szXHnzI02XY1YEWfvHTMre/OROfr75KZbPG2TZvDnuQ2azIMvEWKWIWBAR8yOiP31dXi5OxqY2aSa3QzP7X/7jBzOVY1YEWfvHTMp2DhSz2VesbEsF8vDTuxkeKE1a1yi2vN7+u0bHM5VjVgRZ+8dMynYOFLPZ58FDixy5eC579o9PWtcotrze/iODpUzlmBVB1v4xk7IHS31MpPkdZvu9zHqVBw8t0kxuh2b2/6tXrs5UjlkRZO0fMynbOVDMZp8HDy3STG6HZvZ/72tfkKkcsyLI2j9mUrZzoJjNvizRFi0jaTOwAxgHxiLihHxrNDuyxprX298x69aNWtmum8mJYmbT1xGDh9SrI+KJvCvRq5xLwrqJ27NZa/m2hR2Ii9+6Y++kmPvr796ad9XMMnN7Nmu9Thk8BPBdSb+S9I68K9NrWhlzb9Zubs9mrdcpg4dTIuJ44PXAuyWdWrlR0jsk/VLSLx9//PF8atjFWhlz3wvcPjuL2/Nkbp/WCh0xeIiIR9OfW4GrgBOrtl8WESdExAnLly/Po4pdrZUx973A7bOzuD1P5vZprZD74EHSiKT55dfAHwJ35Fur3tLKmHuzdnN7Nmu9Toi2OAy4ShIk9fnPiPhOvlXqLevXrmATyb3iLU/vZqWfTrcCc3u2vGSZZrvoch88RMQDwLF516PXOZeEdRO3Z+smzQ5KNl9yRotrclDugwdrnmPXzfLj/md2UO7PPFhzHLtulh/3P7PJPHgoCMeum+XH/c9sMg8eCsKx62b5cf8zm8yDh4Jw7LpZftz/zCbzA5MF8c5T13DxtXeye3SM4YESe/aPO3bdrE3c/7pPL4VVtoKvPBTE+rUr2LRhHSvmD7Ftz35WzB9i04Z1ftrbrA3c/8wm85WHAnHsull+3P/MDvLgocAcd27WPu5vZgf5tkVBOe7crH3c38wm8+ChoBx3btY+7m9mk3nwUFCOOzdrH/c3s8k8eCgox52btY/7m9lkHjwU1DtPXcP+8WD36BgRyU/HnZu1hvub2WQePBSU487N2sf9zWwyh2oWmOPOzdrH/c3sIA8ecuKYcZsJtx8zy5NvW+TAMeM2E24/ZpY3X3nIQWXMOMDcwX52j47x7zc84L8ebUpuP9ZrskxitfmSM1pYEyvzlYccOGbcZsLtx8zy5sFDDhwzbjPh9mNmefPgIQeOGbeZcPsxs7z5mYccrF+7gk0k9663PL2blX5a3jJw+zGrL8vzETZ9HjzkxDHjNhNuP2aWJ9+2MDMzs0w8eDAzM7NMPHgwMzOzTPzMg5mZtZ0fbCw2Dx7MzKwh/6K3aoqIvOuQiaTHgd9O878vA56YxeoUTbcf/xMRcXqeFZhh+6xW1O/L9a6tU9rnLor5/cy2orbTVlgG3J2lfRZu8DATkn4ZESfkXY+89PrxF01Rvy/Xu7P1ynFOxZ/DQdP5LPzApJmZmWXiwYOZmZll0muDh8vyrkDOev34i6ao35fr3dl65Tin4s/hoMyfRU8982BmZmYz12tXHszMzGyGemLwIOl0Sf8n6T5JH8y7Pu0m6YuStkq6I++62KEkHSnph5LuknSnpPPT9UskfU/SvenPxXnXtRZJJUm3SPpWurxa0k1pvb8uaTDvOtYiaZGkKyXdnX72JxXlM5+OXj4P1joHdvN3Xc9snmu6fvAgqQR8Dng9cDSwUdLR+daq7b4M5Bpfbg2NAe+PiBcBrwDenbbRDwLXRcRRwHXpcic6H7irYvlfgE+l9X4a+MtcajW1S4HvRMRa4FiSYyjKZ56Jz4M1z4Fd+V1PYdbONV0/eABOBO6LiAciYhT4GvCGnOvUVhFxA/BU3vWw2iLisYi4OX29g+SX2BEk7fSKdLcrgDfmU8P6JK0EzgAuT5cFnAZcme7SqfVeAJwKfAEgIkYj4hkK8JlPU0+fB+ucA7v1u65rNs81vTB4OAJ4uGJ5S7rOrONIWgUcB9wEHBYRj0HS6YEV+dWsrk8DFwIT6fJS4JmIGEuXO7W/rQEeB76U3nK5XNIIxfjMp8PnwUN163fdlJmea3ph8KAa6xxiYh1H0jzgG8D7ImJ73vWZiqQzga0R8avK1TV27cT+1g8cD3w+Io4jSdnczZeti/K9WBvMxrmmFwYPW4AjK5ZXAo/mVBezmiQNkHTmr0TEN9PVv5d0eLr9cGBrXvWr4xRgg6TNJJfBTyO5ErFIUnnSvU7tb1uALRFxU7p8JclgotM/8+nyefBQ3fpdNzRb55peGDz8AjgqfQJ8EDgXuDbnOpkdkD4n8AXgroj4ZMWma4G3pq/fClzT7ro1EhEfioiVEbGKpF/9ICLOA34InJ3u1nH1BoiI3wEPS3phuuo1wG/o8M98BnwePFS3ftd1zea5pieSREn6I5K/iErAFyPiYzlXqa0kfRVYTzJz2u+Bf4yIL+RaKTtA0iuBHwG3c/DZgYtI7kX+F/Ac4CHgnIjoyAdfJa0HPhARZ0paQ3IlYglwC/BnEbEvz/rVIumlJA96DgIPAH9O8gdVIT7zrHr5PFjrHAhcTZd+1/XM5rmmJwYPZmZmNnt64baFmZmZzSIPHszMzCwTDx7MzMwsEw8ezMzMLBMPHszMzCwTDx46gKRPSXpfxfL/SLq8YvkTkv42fX2BpL2SFlaVcaKk69NZ0W6W9G1JL0m3fUTSI5Jurfi3qF3HZ91J0lmSQtLainVHSfqWpPsl/Sqdwe/UdNvbJD1e1Q57aXIma0DSeFXb+GC6/vp0NtDb0hlQP1s+f0laparZgtPz3Qcqlj+Q/r87JP1a0lsqti2XtF/SOyvW3ZS+/0NV7XWVpM2SlqX7rZR0TXrOvV/SpWkODSStT/vGH1eU+600pLkrePDQGX4KnAwgqY8kFnldxfaTgZ+krzeSJHw5q7xR0mEkMboXRcRREXE88HHgeRVlfCoiXlrx75mWHY31io3Aj0kSDiFpCPg2cFlEPC8iXga8h2QeibKvV7XD37S91tap9lS1jUsqtp0XEccAxwD7aDKhk6R3Aa8DToyIF5NMhlaZqvsc4GckbRmAiHh5RLwUuJjJ7XVzRbkCvglcnc5E+QJgHlCZO2ML8PdNHnvhePDQGX5COnggGTTcAeyQtFjSHOBFwC2SnkfSQD9MRWMH/ga4IiJ+Wl4RET+OiKvbUnvrOWlu/FNIpts+N119HnBjRBzIXBgRd0TEl9tfQ+tG6YygFwLPkXRsE//lIuCvy/M3RMS2iLiiYvtG4P3ASklZJgo7DdgbEV9Kyx0HLgD+QtLcdJ9fA9skvS5DuYXhwUMHiIhHgTFJzyEZRNxIkvHrJOAE4La002wEvkqSIeyFksozn60Dbp7ibS6ouPz2w1Ych/WUNwLfiYh7gKckHU9z7fBNVZemh1teUyuK4aq28aZaO6W/qH8NrK21vUzSfGB+RNxfZ/uRwLMi4uckV25rvl8d64DKCeFIBygPAc+vWP1Rkj/2uo4HD52jfPWhPHi4sWK5fEXhXOBrETFBcsnsnFoFpffs7pJ0acXqytsWr27VQVjP2EiSgpr058bqHSRdld5n/mbF6urbFnvaUVkrhOrbFl9vsG/51kO9FMmR7tMohfK5JIMGqNOGp3j/WmVPWh8RPwKQ9KoMZRdC/9S7WJuUn3t4Cclti4dJLqdtB74o6RjgKOB7ye22A/n4PwfcSTIj4DWQ3LOTdDZwZpuPwXqApKUkl21fLClI5koI4J9I7ikDEBFnSToB+NdcKmpdSVKJ5Dx5F/AksLhqlyXAgxGxXdIuSWsi4oEaRW0EDpN0Xrr8bElHRcS9TVTjTuBPquq1gGTm0vuBpRWbPkby7MNYE+UWhq88dI6fkPyyfyoixtNJSRaR3Lq4kaShfyQiVqX/ng0cIem5JAOIt0k6uaK8uZi1xtnAf0TEc9O2eCTwIHAPcIqkDRX7uh3arFEynfTHgYcj4raI2Ak8Juk16fYlwOkkD/KS7vu59Bc7khZIeoeS2VRHIuKI8jk13fdcmnMdMLccuZEOaD4BfDkidlfuGBHfJRngNPOMRmF48NA5bieJsvhZ1bptEfEESaO+qur/XAWcm04v/Cbg45Luk/RTkhP8Zyv2rXzm4VZJq1p0HNb9NnJoW/wG8KckA+B3SXpA0o0k93s/WrFf9TMPJ2OWqH7moTLa4iuSbiO5KjsCvKFi21uAD0u6FfgB8E8Vzzl8nmSK+F+kIZ3/C+ymfhtu6tZFJDNKngWcI+lekoHzXpIHNGv5GLCymbKLwrNqmpmZWSa+8mBmZmaZePBgZmZmmXjwYGZmZpl48GBmZmaZePBgZmZmmXjwYGZmZpl48GBmZmaZePBgZmZmmfw/4gVviyMHtFEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 540x540 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "seaborn.pairplot(data, vars=['WAGE', 'AGE', 'EDUCATION'],kind='reg')\n",
    "  # seaborn.pairplot（）：用来进行数据分析，画两两特征图。\n",
    "  #    （1）vars：list of variable names.\n",
    "  #    （2）kind{‘scatter’, ‘kde’, ‘hist’, ‘reg’}：Kind of plot to make.\n",
    "  #     官网教程：http://seaborn.pydata.org/generated/seaborn.pairplot.html#seaborn.pairplot\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0.98,'Effect of gender: 1=Female, 0=Male')"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 582.375x540 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "seaborn.pairplot(data, vars=['WAGE', 'AGE', 'EDUCATION'],\n",
    "                      kind='reg', hue='SEX')\n",
    "  # hue：name of variable in data\n",
    "  #      Variable in data to map plot aspects to different colors. \n",
    "plt.suptitle('Effect of gender: 1=Female, 0=Male')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0.98,'Effect of race: 1=Other, 2=Hispanic, 3=White')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 582.375x540 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "seaborn.pairplot(data, vars=['WAGE', 'AGE', 'EDUCATION'],\n",
    "                      kind='reg', hue='RACE')\n",
    "plt.suptitle('Effect of race: 1=Other, 2=Hispanic, 3=White')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0.98,'Effect of union: 1=Union member, 0=Not union member')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 582.375x540 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "seaborn.pairplot(data, vars=['WAGE', 'AGE', 'EDUCATION'],\n",
    "                      kind='reg', hue='UNION')\n",
    "plt.suptitle('Effect of union: 1=Union member, 0=Not union member')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
